From ba429d344132c088177e853cce8ff7181570b221 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 10 Apr 2024 19:42:51 +0200 Subject: Adding upstream version 44.2. Signed-off-by: Daniel Baumann --- subprojects/libgd/Makefile.am | 230 ++++ subprojects/libgd/README | 123 ++ subprojects/libgd/libgd.doap | 35 + subprojects/libgd/libgd.m4 | 140 +++ subprojects/libgd/libgd/gd-icon-utils.c | 394 +++++++ subprojects/libgd/libgd/gd-icon-utils.h | 49 + subprojects/libgd/libgd/gd-main-box-child.c | 186 +++ subprojects/libgd/libgd/gd-main-box-child.h | 54 + subprojects/libgd/libgd/gd-main-box-generic.c | 491 ++++++++ subprojects/libgd/libgd/gd-main-box-generic.h | 73 ++ subprojects/libgd/libgd/gd-main-box-item.c | 242 ++++ subprojects/libgd/libgd/gd-main-box-item.h | 55 + subprojects/libgd/libgd/gd-main-box.c | 548 +++++++++ subprojects/libgd/libgd/gd-main-box.h | 61 + subprojects/libgd/libgd/gd-main-icon-box-child.c | 439 +++++++ subprojects/libgd/libgd/gd-main-icon-box-child.h | 43 + subprojects/libgd/libgd/gd-main-icon-box-icon.c | 366 ++++++ subprojects/libgd/libgd/gd-main-icon-box-icon.h | 40 + subprojects/libgd/libgd/gd-main-icon-box.c | 1042 ++++++++++++++++ subprojects/libgd/libgd/gd-main-icon-box.h | 44 + subprojects/libgd/libgd/gd-main-icon-view.c | 440 +++++++ subprojects/libgd/libgd/gd-main-icon-view.h | 42 + subprojects/libgd/libgd/gd-main-list-view.c | 345 ++++++ subprojects/libgd/libgd/gd-main-list-view.h | 80 ++ subprojects/libgd/libgd/gd-main-view-generic.c | 330 ++++++ subprojects/libgd/libgd/gd-main-view-generic.h | 117 ++ subprojects/libgd/libgd/gd-main-view.c | 1160 ++++++++++++++++++ subprojects/libgd/libgd/gd-main-view.h | 65 + subprojects/libgd/libgd/gd-margin-container.c | 377 ++++++ subprojects/libgd/libgd/gd-margin-container.h | 75 ++ subprojects/libgd/libgd/gd-notification.c | 870 ++++++++++++++ subprojects/libgd/libgd/gd-notification.h | 67 ++ subprojects/libgd/libgd/gd-styled-text-renderer.c | 134 +++ subprojects/libgd/libgd/gd-styled-text-renderer.h | 51 + subprojects/libgd/libgd/gd-tagged-entry.c | 1240 ++++++++++++++++++++ subprojects/libgd/libgd/gd-tagged-entry.h | 117 ++ .../libgd/libgd/gd-toggle-pixbuf-renderer.c | 280 +++++ .../libgd/libgd/gd-toggle-pixbuf-renderer.h | 47 + subprojects/libgd/libgd/gd-two-lines-renderer.c | 632 ++++++++++ subprojects/libgd/libgd/gd-two-lines-renderer.h | 43 + subprojects/libgd/libgd/gd-types-catalog.c | 123 ++ subprojects/libgd/libgd/gd-types-catalog.h | 31 + subprojects/libgd/libgd/gd.h | 81 ++ subprojects/libgd/libgd/meson.build | 204 ++++ subprojects/libgd/meson.build | 24 + subprojects/libgd/meson_options.txt | 25 + subprojects/libgd/meson_readme.md | 88 ++ subprojects/libgd/test-tagged-entry-2.c | 131 +++ subprojects/libgd/test-tagged-entry.c | 111 ++ 49 files changed, 11985 insertions(+) create mode 100644 subprojects/libgd/Makefile.am create mode 100644 subprojects/libgd/README create mode 100644 subprojects/libgd/libgd.doap create mode 100644 subprojects/libgd/libgd.m4 create mode 100644 subprojects/libgd/libgd/gd-icon-utils.c create mode 100644 subprojects/libgd/libgd/gd-icon-utils.h create mode 100644 subprojects/libgd/libgd/gd-main-box-child.c create mode 100644 subprojects/libgd/libgd/gd-main-box-child.h create mode 100644 subprojects/libgd/libgd/gd-main-box-generic.c create mode 100644 subprojects/libgd/libgd/gd-main-box-generic.h create mode 100644 subprojects/libgd/libgd/gd-main-box-item.c create mode 100644 subprojects/libgd/libgd/gd-main-box-item.h create mode 100644 subprojects/libgd/libgd/gd-main-box.c create mode 100644 subprojects/libgd/libgd/gd-main-box.h create mode 100644 subprojects/libgd/libgd/gd-main-icon-box-child.c create mode 100644 subprojects/libgd/libgd/gd-main-icon-box-child.h create mode 100644 subprojects/libgd/libgd/gd-main-icon-box-icon.c create mode 100644 subprojects/libgd/libgd/gd-main-icon-box-icon.h create mode 100644 subprojects/libgd/libgd/gd-main-icon-box.c create mode 100644 subprojects/libgd/libgd/gd-main-icon-box.h create mode 100644 subprojects/libgd/libgd/gd-main-icon-view.c create mode 100644 subprojects/libgd/libgd/gd-main-icon-view.h create mode 100644 subprojects/libgd/libgd/gd-main-list-view.c create mode 100644 subprojects/libgd/libgd/gd-main-list-view.h create mode 100644 subprojects/libgd/libgd/gd-main-view-generic.c create mode 100644 subprojects/libgd/libgd/gd-main-view-generic.h create mode 100644 subprojects/libgd/libgd/gd-main-view.c create mode 100644 subprojects/libgd/libgd/gd-main-view.h create mode 100644 subprojects/libgd/libgd/gd-margin-container.c create mode 100644 subprojects/libgd/libgd/gd-margin-container.h create mode 100644 subprojects/libgd/libgd/gd-notification.c create mode 100644 subprojects/libgd/libgd/gd-notification.h create mode 100644 subprojects/libgd/libgd/gd-styled-text-renderer.c create mode 100644 subprojects/libgd/libgd/gd-styled-text-renderer.h create mode 100644 subprojects/libgd/libgd/gd-tagged-entry.c create mode 100644 subprojects/libgd/libgd/gd-tagged-entry.h create mode 100644 subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.c create mode 100644 subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.h create mode 100644 subprojects/libgd/libgd/gd-two-lines-renderer.c create mode 100644 subprojects/libgd/libgd/gd-two-lines-renderer.h create mode 100644 subprojects/libgd/libgd/gd-types-catalog.c create mode 100644 subprojects/libgd/libgd/gd-types-catalog.h create mode 100644 subprojects/libgd/libgd/gd.h create mode 100644 subprojects/libgd/libgd/meson.build create mode 100644 subprojects/libgd/meson.build create mode 100644 subprojects/libgd/meson_options.txt create mode 100644 subprojects/libgd/meson_readme.md create mode 100644 subprojects/libgd/test-tagged-entry-2.c create mode 100644 subprojects/libgd/test-tagged-entry.c (limited to 'subprojects/libgd') diff --git a/subprojects/libgd/Makefile.am b/subprojects/libgd/Makefile.am new file mode 100644 index 0000000..5a07144 --- /dev/null +++ b/subprojects/libgd/Makefile.am @@ -0,0 +1,230 @@ +AUTOMAKE_OPTIONS=subdir-objects +NULL = +CLEANFILES = +MAINTAINERCLEANFILES = +EXTRA_DIST = +noinst_DATA = + +AM_CPPFLAGS = \ + -I$(top_srcdir) \ + -DPREFIX=\"$(prefix)\" \ + -DLIBDIR=\"$(libdir)\" \ + -DG_LOG_DOMAIN=\"libgd\" \ + -DG_DISABLE_DEPRECATED \ + $(LIBGD_CFLAGS) \ + $(NULL) + +noinst_PROGRAMS = + +if LIBGD_STATIC +noinst_LTLIBRARIES = libgd.la +else +pkglib_LTLIBRARIES = libgd.la +endif + +libgd_la_LIBADD = $(LIBGD_LIBS) $(LIBM) +libgd_la_LDFLAGS = -avoid-version +libgd_la_SOURCES = libgd/gd.h +nodist_libgd_la_SOURCES = + +catalog_sources = \ + libgd/gd-types-catalog.c \ + libgd/gd-types-catalog.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(catalog_sources) +EXTRA_DIST += $(catalog_sources) + +if LIBGD_GTK_HACKS +gtk_hacks_sources = \ + libgd/gd-icon-utils.c \ + libgd/gd-icon-utils.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(gtk_hacks_sources) +EXTRA_DIST += $(gtk_hacks_sources) +endif + +if LIBGD__BOX_COMMON +box_common_sources = \ + libgd/gd-main-box-child.c \ + libgd/gd-main-box-child.h \ + libgd/gd-main-box-generic.c \ + libgd/gd-main-box-generic.h \ + libgd/gd-main-box-item.c \ + libgd/gd-main-box-item.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(box_common_sources) +EXTRA_DIST += $(box_common_sources) +endif + +if LIBGD_MAIN_ICON_BOX +main_icon_box_sources = \ + libgd/gd-main-icon-box.c \ + libgd/gd-main-icon-box.h \ + libgd/gd-main-icon-box-child.c \ + libgd/gd-main-icon-box-child.h \ + libgd/gd-main-icon-box-icon.c \ + libgd/gd-main-icon-box-icon.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(main_icon_box_sources) +EXTRA_DIST += $(main_icon_box_sources) +endif + +if LIBGD_MAIN_BOX +main_box_sources = \ + libgd/gd-main-box.c \ + libgd/gd-main-box.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(main_box_sources) +EXTRA_DIST += $(main_box_sources) +endif + +if LIBGD__VIEW_COMMON +view_common_sources = \ + libgd/gd-main-view-generic.c \ + libgd/gd-main-view-generic.h \ + libgd/gd-styled-text-renderer.c \ + libgd/gd-styled-text-renderer.h \ + libgd/gd-two-lines-renderer.c \ + libgd/gd-two-lines-renderer.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(view_common_sources) +EXTRA_DIST += $(view_common_sources) +endif + +if LIBGD_MAIN_ICON_VIEW +main_icon_view_sources = \ + libgd/gd-main-icon-view.c \ + libgd/gd-main-icon-view.h \ + libgd/gd-toggle-pixbuf-renderer.c \ + libgd/gd-toggle-pixbuf-renderer.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(main_icon_view_sources) +EXTRA_DIST += $(main_icon_view_sources) +endif + +if LIBGD_MAIN_LIST_VIEW +main_list_view_sources = \ + libgd/gd-main-list-view.c \ + libgd/gd-main-list-view.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(main_list_view_sources) +EXTRA_DIST += $(main_list_view_sources) +endif + +if LIBGD_MAIN_VIEW +main_view_sources = \ + libgd/gd-main-view.c \ + libgd/gd-main-view.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(main_view_sources) +EXTRA_DIST += $(main_view_sources) +endif + +if LIBGD_MARGIN_CONTAINER +margin_container_sources = \ + libgd/gd-margin-container.c \ + libgd/gd-margin-container.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(margin_container_sources) +EXTRA_DIST += $(margin_container_sources) +endif + +if LIBGD_NOTIFICATION +notification_sources = \ + libgd/gd-notification.c \ + libgd/gd-notification.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(notification_sources) +EXTRA_DIST += $(notification_sources) +endif + +if LIBGD_TAGGED_ENTRY +tagged_entry_sources = \ + libgd/gd-tagged-entry.c \ + libgd/gd-tagged-entry.h \ + $(NULL) + +nodist_libgd_la_SOURCES += $(tagged_entry_sources) +EXTRA_DIST += $(tagged_entry_sources) + +noinst_PROGRAMS += \ + test-tagged-entry \ + test-tagged-entry-2 \ + $(null) + +test_tagged_entry_SOURCES = \ + test-tagged-entry.c \ + $(NULL) +test_tagged_entry_LDADD = \ + $(LIBGD_LIBS) \ + libgd.la \ + $(NULL) + +test_tagged_entry_2_SOURCES = \ + test-tagged-entry-2.c \ + $(NULL) +test_tagged_entry_2_LDADD = \ + $(LIBGD_LIBS) \ + libgd.la \ + $(NULL) +endif + +if LIBGD_GIR +include $(INTROSPECTION_MAKEFILE) +INTROSPECTION_GIRS = Gd-1.0.gir + +Gd-1.0.gir: libgd.la Makefile +Gd_1_0_gir_NAMESPACE = Gd +Gd_1_0_gir_VERSION = 1.0 +Gd_1_0_gir_LIBS = libgd.la +Gd_1_0_gir_CFLAGS = $(AM_CPPFLAGS) +Gd_1_0_gir_SCANNERFLAGS = \ + --warn-all \ + --symbol-prefix=gd \ + --identifier-prefix=Gd \ + --c-include="libgd/gd.h" \ + $(NULL) +Gd_1_0_gir_INCLUDES = $(LIBGD_GIR_INCLUDES) +Gd_1_0_gir_FILES = $(nodist_libgd_la_SOURCES) + +if LIBGD_STATIC +noinst_DATA += Gd-1.0.gir +CLEANFILES += Gd-1.0.gir +else +girdir= $(pkgdatadir)/gir-1.0 +typelibdir= $(pkglibdir)/girepository-1.0 + +gir_DATA = $(INTROSPECTION_GIRS) +typelib_DATA = $(gir_DATA:.gir=.typelib) + +CLEANFILES += $(gir_DATA) $(typelib_DATA) +endif +endif + +if LIBGD_VAPI +VAPIS = gd-1.0.vapi + +gd-1.0.vapi: Gd-1.0.gir + $(AM_V_GEN)$(VAPIGEN) \ + --library gd-1.0 \ + --pkg gtk+-3.0 \ + $< +#This 'touch' is a workaround for vapigen not touching the dest file if +#its content hasn't changed, which causes the rule to generate the .vapi +#file to always trigger + @touch $@ + +noinst_DATA += $(VAPIS) +CLEANFILES += $(VAPIS) +endif diff --git a/subprojects/libgd/README b/subprojects/libgd/README new file mode 100644 index 0000000..fb8c88d --- /dev/null +++ b/subprojects/libgd/README @@ -0,0 +1,123 @@ +===== +libgd +===== + +Introduction +============ + +libgd is a library used by various GNOME 3 styled applications. +However, it is not a typical library, since it doesn't guarantee +API/ABI stability, nor does it has official releases tarballs. Only +the files actually used by your project will be shipped with its +tarball. Only the necessary dependencies will be checked during +configure time and used at runtime. + +Each application can configure libgd depending on its needs and will +be able to either link dynamically (privately) or statically link with +a specific development version. + +GObject Introspection based bindings generation such as Javascript or +Vala are also supported. + +More Background +--------------- + +libgd originates from the GNOME Documents project (written by Cosimo +Cecchi), which was one of the first application to follow the novel +GNOME 3 application design. + +Since other applications have similar needs, it makes sense to try to +reuse and improve the existing work. However, the design being not +frozen, and the code being not yet matured enough and proven, it is +not possible for the developers to guarantee API and propose the +addition to the respective projects (Gtk+, or GLib for example) right +now. Sharing the code allows to experiment, discuss and test together +before proposing it upstream. + +Traditionally, this problem is solved by copying often outdated +snippets of code around (due to no API/ABI guarantee), often not +centralized (libegg). + +In the past, there used to be some common aging GNOME application +libraries above Gtk+ which have been slowly deprecated in favour of +Gtk+ (gnomeui and friends). + +All approaches have pros and cons. A configurable git submodule +has the following advantages: + +- no direct code copying necessary because API/ABI breakage (history + is preserved etc..) +- code is shared and maintained in a common project +- you can stick to a particular upstream version, or branch off your + own version easily if needed (hopefully you find your way back upstream) +- update the submodule version when your project is ready +- the libgd options should help you to configure a library to suit + your needs, taking care of some of autofoo stuff for you + +Usage +===== + +In order to use libgd, an application using autotools needs to: + +1. from the top-level project directory, add the submodule: + - git submodule add git://git.gnome.org/libgd + +2. in autogen.sh, it is recommended to add before autoreconf call: + - git submodule update --init --recursive + +3. in top-level Makefile.am: + - add -I libgd to ACLOCAL_AMFLAGS + - add libgd to SUBDIRS, before the project src directory + +4. in project configure.ac: + - add LIBGD_INIT([list-of-options]) after your project + dependencies checks + - add libgd/Makefile to AC_CONFIG_FILES + +5. from your program Makefile.am, you may now for example: + - link with $(top_builddir)/libgd/libgd.la, and include + (adjust your AM_CPPFLAGS as necessary) + +You may be interested to look at the commit switching GNOME Boxes from +private libgd usage to the libgd submodule: + +http://git.gnome.org/browse/gnome-boxes/commit/?id=395652458d8b311a25ecb27cc42287602a122b1f + +Note for example that the submodule url is "../libgd", which is a +better alternative for projects hosted on git.gnome.org. It will allow +the submodule update to reuse the address and the credentials given to +the toplevel project. + +LIBGD_INIT options +================== + +- gtk-hacks + +- main-icon-view + +- margin-container + +- notification + +- static + +- tagged-entry + +- vapi + +- gir + +How to modify or add an API? +============================ + + +TODO +==== + +- add translation support +- add some form of build test +- document: options, modification process +- eventually add documentation generation +- some licensing check +- more modularity (not all in libgd.m4/Makefile.am) +- CSS styling and data: shared only with gnome-themes-standard? diff --git a/subprojects/libgd/libgd.doap b/subprojects/libgd/libgd.doap new file mode 100644 index 0000000..6fd9c8b --- /dev/null +++ b/subprojects/libgd/libgd.doap @@ -0,0 +1,35 @@ + + + libgd + A common GNOME 3 applications submodule + No long description yet + + + + + + + + + Cosimo Cecchi + + cosimoc + + + + + Marc-André Lureau + + malureau + + + + diff --git a/subprojects/libgd/libgd.m4 b/subprojects/libgd/libgd.m4 new file mode 100644 index 0000000..b71e344 --- /dev/null +++ b/subprojects/libgd/libgd.m4 @@ -0,0 +1,140 @@ +dnl The option stuff below is based on the similar code from Automake + +# _LIBGD_MANGLE_OPTION(NAME) +# ------------------------- +# Convert NAME to a valid m4 identifier, by replacing invalid characters +# with underscores, and prepend the _LIBGD_OPTION_ suffix to it. +AC_DEFUN([_LIBGD_MANGLE_OPTION], +[[_LIBGD_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) + +# _LIBGD_SET_OPTION(NAME) +# ---------------------- +# Set option NAME. If NAME begins with a digit, treat it as a requested +# Guile version number, and define _LIBGD_GUILE_VERSION to that number. +# Otherwise, define the option using _LIBGD_MANGLE_OPTION. +AC_DEFUN([_LIBGD_SET_OPTION], +[m4_define(_LIBGD_MANGLE_OPTION([$1]), 1)]) + +# _LIBGD_SET_OPTIONS(OPTIONS) +# ---------------------------------- +# OPTIONS is a space-separated list of libgd options. +AC_DEFUN([_LIBGD_SET_OPTIONS], +[m4_foreach_w([_LIBGD_Option], [$1], [_LIBGD_SET_OPTION(_LIBGD_Option)])]) + +# _LIBGD_IF_OPTION_SET(NAME,IF-SET,IF-NOT-SET) +# ------------------------------------------- +# Check if option NAME is set. +AC_DEFUN([_LIBGD_IF_OPTION_SET], +[m4_ifset(_LIBGD_MANGLE_OPTION([$1]),[$2],[$3])]) + +dnl LIBGD_INIT([OPTIONS], [DIR]) +dnl ---------------------------- +dnl OPTIONS A whitespace-seperated list of options. +dnl DIR libgd submodule directory (defaults to 'libgd') +AC_DEFUN([LIBGD_INIT], [ + _LIBGD_SET_OPTIONS([$1]) + AC_SUBST([LIBGD_MODULE_DIR],[m4_if([$2],,[libgd],[$2])]) + + AC_REQUIRE([LT_INIT]) + AC_REQUIRE([AC_CHECK_LIBM]) + AC_SUBST(LIBM) + LIBGD_MODULES="gtk+-3.0 >= 3.7.10" + LIBGD_GIR_INCLUDES="Gtk-3.0" + LIBGD_SOURCES="" + + AM_CONDITIONAL([LIBGD_STATIC],[_LIBGD_IF_OPTION_SET([static],[true],[false])]) + + # main-box: + AM_CONDITIONAL([LIBGD_MAIN_BOX],[_LIBGD_IF_OPTION_SET([main-box],[true],[false])]) + _LIBGD_IF_OPTION_SET([main-box],[ + _LIBGD_SET_OPTION([main-icon-box]) + AC_DEFINE([LIBGD_MAIN_BOX], [1], [Description]) + ]) + + # main-icon-box: + AM_CONDITIONAL([LIBGD_MAIN_ICON_BOX],[_LIBGD_IF_OPTION_SET([main-icon-box],[true],[false])]) + _LIBGD_IF_OPTION_SET([main-icon-box],[ + _LIBGD_SET_OPTION([_box-common]) + _LIBGD_SET_OPTION([gtk-hacks]) + AC_DEFINE([LIBGD_MAIN_ICON_BOX], [1], [Description]) + ]) + + # main-view: + AM_CONDITIONAL([LIBGD_MAIN_VIEW],[_LIBGD_IF_OPTION_SET([main-view],[true],[false])]) + _LIBGD_IF_OPTION_SET([main-view],[ + _LIBGD_SET_OPTION([main-icon-view]) + _LIBGD_SET_OPTION([main-list-view]) + _LIBGD_SET_OPTION([gtk-hacks]) + AC_DEFINE([LIBGD_MAIN_VIEW], [1], [Description]) + ]) + + # main-icon-view: + AM_CONDITIONAL([LIBGD_MAIN_ICON_VIEW],[_LIBGD_IF_OPTION_SET([main-icon-view],[true],[false])]) + _LIBGD_IF_OPTION_SET([main-icon-view],[ + _LIBGD_SET_OPTION([_view-common]) + AC_DEFINE([LIBGD_MAIN_ICON_VIEW], [1], [Description]) + ]) + + # main-list-view: + AM_CONDITIONAL([LIBGD_MAIN_LIST_VIEW],[_LIBGD_IF_OPTION_SET([main-list-view],[true],[false])]) + _LIBGD_IF_OPTION_SET([main-list-view],[ + _LIBGD_SET_OPTION([_view-common]) + AC_DEFINE([LIBGD_MAIN_LIST_VIEW], [1], [Description]) + ]) + + # margin-container: + AM_CONDITIONAL([LIBGD_MARGIN_CONTAINER],[_LIBGD_IF_OPTION_SET([margin-container],[true],[false])]) + _LIBGD_IF_OPTION_SET([margin-container],[ + AC_DEFINE([LIBGD_MARGIN_CONTAINER], [1], [Description]) + ]) + + # notification: + AM_CONDITIONAL([LIBGD_NOTIFICATION],[_LIBGD_IF_OPTION_SET([notification],[true],[false])]) + _LIBGD_IF_OPTION_SET([notification],[ + AC_DEFINE([LIBGD_NOTIFICATION], [1], [Description]) + ]) + + # tagged-entry: Gtk+ widget + AM_CONDITIONAL([LIBGD_TAGGED_ENTRY],[_LIBGD_IF_OPTION_SET([tagged-entry],[true],[false])]) + _LIBGD_IF_OPTION_SET([tagged-entry],[ + AC_DEFINE([LIBGD_TAGGED_ENTRY], [1], [Description]) + ]) + + # vapi: vala bindings support + AM_CONDITIONAL([LIBGD_VAPI],[ _LIBGD_IF_OPTION_SET([vapi],[true],[false])]) + _LIBGD_IF_OPTION_SET([vapi],[ + _LIBGD_SET_OPTION([gir]) + dnl check for vapigen + AC_PATH_PROG(VAPIGEN, vapigen, no) + AS_IF([test x$VAPIGEN = "xno"], + [AC_MSG_ERROR([Cannot find the "vapigen compiler in your PATH])]) + ]) + + # gir: gobject introspection support + AM_CONDITIONAL([LIBGD_GIR],[ _LIBGD_IF_OPTION_SET([gir],[true],[false])]) + _LIBGD_IF_OPTION_SET([gir],[ + GOBJECT_INTROSPECTION_REQUIRE([0.9.6]) + ]) + + # gtk-hacks: collection of Gtk+ hacks and workarounds + AM_CONDITIONAL([LIBGD_GTK_HACKS],[_LIBGD_IF_OPTION_SET([gtk-hacks],[true],[false])]) + _LIBGD_IF_OPTION_SET([gtk-hacks],[ + AC_DEFINE([LIBGD_GTK_HACKS], [1], [Description]) + ]) + + # _box-common: + AM_CONDITIONAL([LIBGD__BOX_COMMON],[_LIBGD_IF_OPTION_SET([_box-common],[true],[false])]) + _LIBGD_IF_OPTION_SET([_box-common],[ + AC_DEFINE([LIBGD__BOX_COMMON], [1], [Description]) + ]) + + # _view-common: + AM_CONDITIONAL([LIBGD__VIEW_COMMON],[_LIBGD_IF_OPTION_SET([_view-common],[true],[false])]) + _LIBGD_IF_OPTION_SET([_view-common],[ + AC_DEFINE([LIBGD__VIEW_COMMON], [1], [Description]) + ]) + + PKG_CHECK_MODULES(LIBGD, [ $LIBGD_MODULES ]) + AC_SUBST(LIBGD_GIR_INCLUDES) + AC_SUBST(LIBGD_SOURCES) +]) diff --git a/subprojects/libgd/libgd/gd-icon-utils.c b/subprojects/libgd/libgd/gd-icon-utils.c new file mode 100644 index 0000000..6c9dd40 --- /dev/null +++ b/subprojects/libgd/libgd/gd-icon-utils.c @@ -0,0 +1,394 @@ +/* + * Copyright (c) 2011, 2012, 2015, 2016 Red Hat, Inc. + * + * Gnome Documents 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. + * + * Gnome Documents is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * 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 Gnome Documents; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-icon-utils.h" + +#include +#include +#include + +#define _BG_MIN_SIZE 20 +#define _EMBLEM_MIN_SIZE 8 + +/** + * gd_copy_image_surface: + * @surface: + * + * Returns: (transfer full): + */ +cairo_surface_t * +gd_copy_image_surface (cairo_surface_t *surface) +{ + cairo_surface_t *copy = NULL; + cairo_t *cr; + gdouble scale_x; + gdouble scale_y; + + copy = cairo_surface_create_similar_image (surface, CAIRO_FORMAT_ARGB32, + cairo_image_surface_get_width (surface), + cairo_image_surface_get_height (surface)); + cairo_surface_get_device_scale (surface, &scale_x, &scale_y); + cairo_surface_set_device_scale (copy, scale_x, scale_y); + + cr = cairo_create (copy); + cairo_set_source_surface (cr, surface, 0, 0); + cairo_paint (cr); + cairo_destroy (cr); + + return copy; +} + +/** + * gd_create_surface_with_counter: + * @widget: + * @base: + * @number: + * + * Returns: (transfer full): + */ +cairo_surface_t * +gd_create_surface_with_counter (GtkWidget *widget, cairo_surface_t *base, gint number) +{ + GtkStyleContext *context; + cairo_t *cr, *emblem_cr; + cairo_surface_t *emblem_surface; + cairo_surface_t *surface; + gint height; + gint height_scaled; + gint width; + gint width_scaled; + gint layout_width, layout_height; + gint emblem_size; + gint emblem_size_scaled; + gdouble scale; + gdouble scale_x; + gdouble scale_y; + gchar *str; + PangoLayout *layout; + PangoAttrList *attr_list; + PangoAttribute *attr; + PangoFontDescription *desc; + GdkRGBA color; + + context = gtk_widget_get_style_context (GTK_WIDGET (widget)); + gtk_style_context_save (context); + gtk_style_context_add_class (context, "documents-counter"); + + width_scaled = cairo_image_surface_get_width (base); + height_scaled = cairo_image_surface_get_height (base); + cairo_surface_get_device_scale (base, &scale_x, &scale_y); + + width = width_scaled / (gint) floor (scale_x), + height = height_scaled / (gint) floor (scale_y); + + surface = cairo_surface_create_similar_image (base, CAIRO_FORMAT_ARGB32, + width_scaled, height_scaled); + cairo_surface_set_device_scale (surface, scale_x, scale_y); + + cr = cairo_create (surface); + cairo_set_source_surface (cr, base, 0, 0); + cairo_paint (cr); + + emblem_size_scaled = MIN (width_scaled / 2, height_scaled / 2); + emblem_size = MIN (width / 2, height / 2); + + emblem_surface = cairo_surface_create_similar_image (base, CAIRO_FORMAT_ARGB32, + emblem_size_scaled, emblem_size_scaled); + cairo_surface_set_device_scale (emblem_surface, scale_x, scale_y); + + emblem_cr = cairo_create (emblem_surface); + gtk_render_background (context, emblem_cr, + 0, 0, emblem_size, emblem_size); + + if (number > 99) + number = 99; + if (number < -99) + number = -99; + + str = g_strdup_printf ("%d", number); + layout = gtk_widget_create_pango_layout (GTK_WIDGET (widget), str); + g_free (str); + + pango_layout_get_pixel_size (layout, &layout_width, &layout_height); + + /* scale the layout to be 0.5 of the size still available for drawing */ + scale = (emblem_size * 0.50) / (MAX (layout_width, layout_height)); + attr_list = pango_attr_list_new (); + + attr = pango_attr_scale_new (scale); + pango_attr_list_insert (attr_list, attr); + pango_layout_set_attributes (layout, attr_list); + + gtk_style_context_get (context, GTK_STATE_FLAG_NORMAL, "font", &desc, NULL); + pango_layout_set_font_description (layout, desc); + pango_font_description_free (desc); + + gtk_style_context_get_color (context, 0, &color); + gdk_cairo_set_source_rgba (emblem_cr, &color); + + /* update these values */ + pango_layout_get_pixel_size (layout, &layout_width, &layout_height); + + cairo_move_to (emblem_cr, + emblem_size / 2 - layout_width / 2, + emblem_size / 2 - layout_height / 2); + + pango_cairo_show_layout (emblem_cr, layout); + + g_object_unref (layout); + pango_attr_list_unref (attr_list); + cairo_destroy (emblem_cr); + + cairo_set_source_surface (cr, emblem_surface, + width - emblem_size, height - emblem_size); + cairo_paint (cr); + cairo_destroy (cr); + + cairo_surface_destroy (emblem_surface); + gtk_style_context_restore (context); + + return surface; +} + +/** + * gd_create_symbolic_icon_for_scale: + * @name: + * @base_size: + * @scale: + * + * Returns: (transfer full): + */ +GIcon * +gd_create_symbolic_icon_for_scale (const gchar *name, + gint base_size, + gint scale) +{ + gchar *symbolic_name; + GIcon *icon, *retval = NULL; + cairo_surface_t *icon_surface; + cairo_surface_t *surface; + cairo_t *cr; + GtkStyleContext *style; + GtkWidgetPath *path; + GdkPixbuf *pixbuf; + GtkIconTheme *theme; + GtkIconInfo *info; + gint bg_size; + gint emblem_size; + gint total_size; + gint total_size_scaled; + + total_size = base_size / 2; + total_size_scaled = total_size * scale; + + bg_size = MAX (total_size / 2, _BG_MIN_SIZE); + emblem_size = MAX (bg_size - 8, _EMBLEM_MIN_SIZE); + + surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, total_size_scaled, total_size_scaled); + cairo_surface_set_device_scale (surface, (gdouble) scale, (gdouble) scale); + cr = cairo_create (surface); + + style = gtk_style_context_new (); + + path = gtk_widget_path_new (); + gtk_widget_path_append_type (path, GTK_TYPE_ICON_VIEW); + gtk_style_context_set_path (style, path); + gtk_widget_path_unref (path); + + gtk_style_context_add_class (style, "documents-icon-bg"); + + gtk_render_background (style, cr, (total_size - bg_size) / 2, (total_size - bg_size) / 2, bg_size, bg_size); + + symbolic_name = g_strconcat (name, "-symbolic", NULL); + icon = g_themed_icon_new_with_default_fallbacks (symbolic_name); + g_free (symbolic_name); + + theme = gtk_icon_theme_get_default(); + info = gtk_icon_theme_lookup_by_gicon_for_scale (theme, icon, emblem_size, scale, + GTK_ICON_LOOKUP_FORCE_SIZE); + g_object_unref (icon); + + if (info == NULL) + goto out; + + pixbuf = gtk_icon_info_load_symbolic_for_context (info, style, NULL, NULL); + g_object_unref (info); + + if (pixbuf == NULL) + goto out; + + icon_surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale, NULL); + g_object_unref (pixbuf); + + gtk_render_icon_surface (style, cr, icon_surface, (total_size - emblem_size) / 2, (total_size - emblem_size) / 2); + cairo_surface_destroy (icon_surface); + + retval = G_ICON (gdk_pixbuf_get_from_surface (surface, 0, 0, total_size_scaled, total_size_scaled)); + + out: + g_object_unref (style); + cairo_surface_destroy (surface); + cairo_destroy (cr); + + return retval; +} + +/** + * gd_create_symbolic_icon: + * @name: + * @base_size: + * + * Returns: (transfer full): + */ +GIcon * +gd_create_symbolic_icon (const gchar *name, + gint base_size) +{ + return gd_create_symbolic_icon_for_scale (name, base_size, 1); +} + +/** + * gd_embed_surface_in_frame: + * @source_image: + * @frame_image_url: + * @slice_width: + * @border_width: + * + * Returns: (transfer full): + */ +cairo_surface_t * +gd_embed_surface_in_frame (cairo_surface_t *source_image, + const gchar *frame_image_url, + GtkBorder *slice_width, + GtkBorder *border_width) +{ + cairo_surface_t *surface; + cairo_t *cr; + int source_width, source_height; + gchar *css_str; + GtkCssProvider *provider; + GtkStyleContext *context; + GError *error = NULL; + GtkWidgetPath *path; + gdouble scale_x, scale_y; + + cairo_surface_get_device_scale (source_image, &scale_x, &scale_y); + + source_width = cairo_image_surface_get_width (source_image) / (gint) floor (scale_x), + source_height = cairo_image_surface_get_height (source_image) / (gint) floor (scale_y); + + css_str = g_strdup_printf (".embedded-image { border-image: url(\"%s\") %d %d %d %d / %dpx %dpx %dpx %dpx }", + frame_image_url, + slice_width->top, slice_width->right, slice_width->bottom, slice_width->left, + border_width->top, border_width->right, border_width->bottom, border_width->left); + provider = gtk_css_provider_new (); + gtk_css_provider_load_from_data (provider, css_str, -1, &error); + + if (error != NULL) + { + g_warning ("Unable to create the thumbnail frame image: %s", error->message); + g_error_free (error); + g_free (css_str); + + return g_object_ref (source_image); + } + + surface = cairo_surface_create_similar (source_image, + CAIRO_CONTENT_COLOR_ALPHA, + source_width, source_height); + cr = cairo_create (surface); + + context = gtk_style_context_new (); + path = gtk_widget_path_new (); + gtk_widget_path_append_type (path, GTK_TYPE_ICON_VIEW); + + gtk_style_context_set_path (context, path); + gtk_style_context_add_provider (context, + GTK_STYLE_PROVIDER (provider), + GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + + cairo_save (cr); + cairo_rectangle (cr, + border_width->left, + border_width->top, + source_width - border_width->left - border_width->right, + source_height - border_width->top - border_width->bottom); + cairo_clip (cr); + gtk_render_icon_surface (context, cr, + source_image, + 0, 0); + cairo_restore (cr); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, "embedded-image"); + + gtk_render_frame (context, cr, + 0, 0, + source_width, source_height); + + gtk_style_context_restore (context); + cairo_destroy (cr); + + gtk_widget_path_unref (path); + g_object_unref (provider); + g_object_unref (context); + g_free (css_str); + + return surface; +} + +/** + * gd_embed_image_in_frame: + * @source_image: + * @frame_image_url: + * @slice_width: + * @border_width: + * + * Returns: (transfer full): + */ +GdkPixbuf * +gd_embed_image_in_frame (GdkPixbuf *source_image, + const gchar *frame_image_url, + GtkBorder *slice_width, + GtkBorder *border_width) +{ + cairo_surface_t *surface, *embedded_surface; + GdkPixbuf *retval; + + surface = gdk_cairo_surface_create_from_pixbuf (source_image, + 0, NULL); + + /* Force the device scale to 1.0, since pixbufs are always in unscaled + * dimensions. + */ + cairo_surface_set_device_scale (surface, 1.0, 1.0); + embedded_surface = gd_embed_surface_in_frame (surface, frame_image_url, + slice_width, border_width); + retval = gdk_pixbuf_get_from_surface (embedded_surface, + 0, 0, + cairo_image_surface_get_width (embedded_surface), + cairo_image_surface_get_height (embedded_surface)); + + cairo_surface_destroy (embedded_surface); + cairo_surface_destroy (surface); + + return retval; +} diff --git a/subprojects/libgd/libgd/gd-icon-utils.h b/subprojects/libgd/libgd/gd-icon-utils.h new file mode 100644 index 0000000..12f4f06 --- /dev/null +++ b/subprojects/libgd/libgd/gd-icon-utils.h @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2011, 2012, 2015, 2016 Red Hat, Inc. + * + * Gnome Documents 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. + * + * Gnome Documents is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * 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 Gnome Documents; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef __GD_CREATE_SYMBOLIC_ICON_H__ +#define __GD_CREATE_SYMBOLIC_ICON_H__ + +#include +#include + +cairo_surface_t *gd_copy_image_surface (cairo_surface_t *surface); + +cairo_surface_t *gd_create_surface_with_counter (GtkWidget *widget, + cairo_surface_t *base, + gint number); + +GIcon *gd_create_symbolic_icon (const gchar *name, + gint base_size); +GIcon *gd_create_symbolic_icon_for_scale (const gchar *name, + gint base_size, + gint scale); + +GdkPixbuf *gd_embed_image_in_frame (GdkPixbuf *source_image, + const gchar *frame_image_url, + GtkBorder *slice_width, + GtkBorder *border_width); +cairo_surface_t *gd_embed_surface_in_frame (cairo_surface_t *source_image, + const gchar *frame_image_url, + GtkBorder *slice_width, + GtkBorder *border_width); + +#endif /* __GD_CREATE_SYMBOLIC_ICON_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-box-child.c b/subprojects/libgd/libgd/gd-main-box-child.c new file mode 100644 index 0000000..9a1118d --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box-child.c @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2016, 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#include "gd-main-box-child.h" + +G_DEFINE_INTERFACE (GdMainBoxChild, gd_main_box_child, GTK_TYPE_WIDGET) + +static void +gd_main_box_child_default_init (GdMainBoxChildInterface *iface) +{ + GParamSpec *pspec; + + /** + * GdMainBoxChild:item: + * + * A #GdMainBoxItem that is rendered by the #GdMainBoxChild widget. + */ + pspec = g_param_spec_object ("item", + "Item", + "An item that is rendered by the widget", + GD_TYPE_MAIN_BOX_ITEM, + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxChild:selection-mode: + * + * Whether the #GdMainBoxChild widget is in selection mode. + */ + pspec = g_param_spec_boolean ("selection-mode", + "Selection mode", + "Whether the child is in selection mode", + FALSE, + G_PARAM_CONSTRUCT | + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxChild:show-primary-text: + * + * Whether the #GdMainBoxChild widget is going to show the + * primary-text of its item. + */ + pspec = g_param_spec_boolean ("show-primary-text", + "Show Primary Text", + "Whether the item's primary-text is going to be shown", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxChild:show-secondary-text: + * + * Whether the #GdMainBoxChild widget is going to show the + * secondary-text of its item. + */ + pspec = g_param_spec_boolean ("show-secondary-text", + "Show Secondary Text", + "Whether the item's secondary-text is going to be shown", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); +} + +/** + * gd_main_box_child_get_item: + * @self: + * + * Returns: (transfer none): The #GdMainBoxItem + */ +GdMainBoxItem * +gd_main_box_child_get_item (GdMainBoxChild *self) +{ + GdMainBoxChildInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_CHILD (self), NULL); + + iface = GD_MAIN_BOX_CHILD_GET_IFACE (self); + + return (* iface->get_item) (self); +} + +/** + * gd_main_box_child_get_index: + * @self: + * + * Returns: (transfer none): The index + */ +gint +gd_main_box_child_get_index (GdMainBoxChild *self) +{ + GdMainBoxChildInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_CHILD (self), -1); + + iface = GD_MAIN_BOX_CHILD_GET_IFACE (self); + + return (* iface->get_index) (self); +} + +/** + * gd_main_box_child_get_selected: + * @self: + * + * Returns: (transfer none): Whether @self is selected + */ +gboolean +gd_main_box_child_get_selected (GdMainBoxChild *self) +{ + GdMainBoxChildInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_CHILD (self), FALSE); + + iface = GD_MAIN_BOX_CHILD_GET_IFACE (self); + + return (* iface->get_selected) (self); +} + +/** + * gd_main_box_child_get_selection_mode: + * @self: + * + * Returns: (transfer none): Whether @self is in selection mode + */ +gboolean +gd_main_box_child_get_selection_mode (GdMainBoxChild *self) +{ + gboolean selection_mode; + + g_return_val_if_fail (GD_IS_MAIN_BOX_CHILD (self), FALSE); + + g_object_get (self, "selection-mode", &selection_mode, NULL); + return selection_mode; +} + +/** + * gd_main_box_child_set_selected: + * @self: + * @selected: + */ +void +gd_main_box_child_set_selected (GdMainBoxChild *self, gboolean selected) +{ + GdMainBoxChildInterface *iface; + + g_return_if_fail (GD_IS_MAIN_BOX_CHILD (self)); + + iface = GD_MAIN_BOX_CHILD_GET_IFACE (self); + + return (* iface->set_selected) (self, selected); +} + +/** + * gd_main_box_child_set_selection_mode: + * @self: + * @selection_mode: + */ +void +gd_main_box_child_set_selection_mode (GdMainBoxChild *self, gboolean selection_mode) +{ + g_return_if_fail (GD_IS_MAIN_BOX_CHILD (self)); + g_object_set (self, "selection-mode", selection_mode, NULL); +} diff --git a/subprojects/libgd/libgd/gd-main-box-child.h b/subprojects/libgd/libgd/gd-main-box-child.h new file mode 100644 index 0000000..b2600a6 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box-child.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#ifndef __GD_MAIN_BOX_CHILD_H__ +#define __GD_MAIN_BOX_CHILD_H__ + +#include + +#include "gd-main-box-item.h" + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_BOX_CHILD gd_main_box_child_get_type() +G_DECLARE_INTERFACE (GdMainBoxChild, gd_main_box_child, GD, MAIN_BOX_CHILD, GtkWidget) + +struct _GdMainBoxChildInterface +{ + GTypeInterface base_iface; + + /* vtable */ + gint (* get_index) (GdMainBoxChild *self); + GdMainBoxItem * (* get_item) (GdMainBoxChild *self); + gboolean (* get_selected) (GdMainBoxChild *self); + void (* set_selected) (GdMainBoxChild *self, gboolean selected); +}; + +gint gd_main_box_child_get_index (GdMainBoxChild *self); +GdMainBoxItem * gd_main_box_child_get_item (GdMainBoxChild *self); +gboolean gd_main_box_child_get_selected (GdMainBoxChild *self); +gboolean gd_main_box_child_get_selection_mode (GdMainBoxChild *self); +void gd_main_box_child_set_selected (GdMainBoxChild *self, gboolean selected); +void gd_main_box_child_set_selection_mode (GdMainBoxChild *self, gboolean selection_mode); + +G_END_DECLS + +#endif /* __GD_MAIN_BOX_CHILD_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-box-generic.c b/subprojects/libgd/libgd/gd-main-box-generic.c new file mode 100644 index 0000000..0d18764 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box-generic.c @@ -0,0 +1,491 @@ +/* + * Copyright (c) 2016, 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#include "gd-main-box-generic.h" +#include "gd-main-box-item.h" + +enum +{ + ITEM_ACTIVATED, + SELECTION_CHANGED, + SELECTION_MODE_REQUEST, + NUM_SIGNALS +}; + +static guint signals[NUM_SIGNALS] = { 0, }; + +G_DEFINE_INTERFACE (GdMainBoxGeneric, gd_main_box_generic, GTK_TYPE_WIDGET) + +static void +gd_main_box_generic_mark_range_as_selected (GdMainBoxGeneric *self, gint first_element, gint last_element) +{ + gint i; + + if (first_element > last_element) + { + gint tmp; + + tmp = first_element; + first_element = last_element; + last_element = tmp; + } + + for (i = first_element; i <= last_element; i++) + { + GdMainBoxChild *child; + + child = gd_main_box_generic_get_child_at_index (self, i); + gd_main_box_generic_select_child (self, child); + } +} + +static void +gd_main_box_generic_select_range (GdMainBoxGeneric *self, GdMainBoxChild *child) +{ + GListModel *model; + const gchar *last_selected_id; + gint index; + gint other_index = -1; + guint n_items; + + model = gd_main_box_generic_get_model (self); + n_items = g_list_model_get_n_items (model); + + last_selected_id = gd_main_box_generic_get_last_selected_id (self); + index = gd_main_box_child_get_index (child); + + if (last_selected_id != NULL) + { + guint i; + + for (i = 0; i < n_items; i++) + { + GdMainBoxItem *item; + const gchar *id; + + item = GD_MAIN_BOX_ITEM (g_list_model_get_object (model, i)); + id = gd_main_box_item_get_id (item); + + if (g_strcmp0 (id, last_selected_id) == 0) + { + other_index = (gint) i; + g_object_unref (item); + break; + } + + g_object_unref (item); + } + } + + if (other_index == -1) + { + gint i; + + for (i = index - 1; i >= 0; i--) + { + GdMainBoxChild *other; + + other = gd_main_box_generic_get_child_at_index (self, i); + if (gd_main_box_child_get_selected (other)) + { + other_index = i; + break; + } + } + } + + if (other_index == -1) + { + gint i; + + for (i = index + 1; i < (gint) n_items; i++) + { + GdMainBoxChild *other; + + other = gd_main_box_generic_get_child_at_index (self, i); + if (gd_main_box_child_get_selected (other)) + { + other_index = i; + break; + } + } + } + + if (other_index == -1) + gd_main_box_generic_select_child (self, child); + else + gd_main_box_generic_mark_range_as_selected (self, index, other_index); +} + +static void +gd_main_box_generic_default_init (GdMainBoxGenericInterface *iface) +{ + GParamSpec *pspec; + + /** + * GdMainBoxGeneric:last-selected-id: + * + * A unique ID to identify the #GdMainBoxItem object that was most + * recently selected. + */ + pspec = g_param_spec_string ("last-selected-id", + "ID", + "A unique ID to identify the most recently selected item", + NULL, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxGeneric:model: + * + * A #GListModel that is rendered by the #GdMainBoxGeneric widget. + */ + pspec = g_param_spec_object ("model", + "Model", + "A model that is rendered by the widget", + G_TYPE_LIST_MODEL, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxGeneric:gd-selection-mode: + * + * Whether the #GdMainBoxGeneric widget is in selection mode. + */ + pspec = g_param_spec_boolean ("gd-selection-mode", + "Selection Mode", + "Whether the widget is in selection mode", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxGeneric:show-primary-text: + * + * Whether the #GdMainBoxGeneric widget is going to show the + * primary-text of each #GdMainBoxItem. + */ + pspec = g_param_spec_boolean ("show-primary-text", + "Show Primary Text", + "Whether each GdMainBoxItem's primary-text is going to be shown", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxGeneric:show-secondary-text: + * + * Whether the #GdMainBoxGeneric widget is going to show the + * secondary-text of each #GdMainBoxItem. + */ + pspec = g_param_spec_boolean ("show-secondary-text", + "Show Secondary Text", + "Whether each GdMainBoxItem's secondary-text is going to be shown", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + signals[ITEM_ACTIVATED] = g_signal_new ("item-activated", + GD_TYPE_MAIN_BOX_GENERIC, + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, + 1, + GD_TYPE_MAIN_BOX_CHILD); + + signals[SELECTION_CHANGED] = g_signal_new ("selection-changed", + GD_TYPE_MAIN_BOX_GENERIC, + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + signals[SELECTION_MODE_REQUEST] = g_signal_new ("selection-mode-request", + GD_TYPE_MAIN_BOX_GENERIC, + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); +} + +/** + * gd_main_box_generic_get_child_at_index: + * @self: + * @index: + * + * Returns: (transfer none): The child at @index. + */ +GdMainBoxChild * +gd_main_box_generic_get_child_at_index (GdMainBoxGeneric *self, gint index) +{ + GdMainBoxGenericInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_GENERIC (self), NULL); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + return (* iface->get_child_at_index) (self, index); +} + +/** + * gd_main_box_generic_get_last_selected_id: + * @self: + * + * Returns: (transfer none): The ID of the most recently selected #GdMainBoxItem. + */ +const gchar * +gd_main_box_generic_get_last_selected_id (GdMainBoxGeneric *self) +{ + GdMainBoxGenericInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_GENERIC (self), NULL); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + return (* iface->get_last_selected_id) (self); +} + +/** + * gd_main_box_generic_get_model: + * @self: + * + * Returns: (transfer none): The associated model + */ +GListModel * +gd_main_box_generic_get_model (GdMainBoxGeneric *self) +{ + GdMainBoxGenericInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_GENERIC (self), NULL); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + return (* iface->get_model) (self); +} + +/** + * gd_main_box_generic_get_selected_children: + * @self: + * + * Returns: (element-type GdMainBoxChild) (transfer container): The + * selected children + */ +GList * +gd_main_box_generic_get_selected_children (GdMainBoxGeneric *self) +{ + GdMainBoxGenericInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_GENERIC (self), NULL); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + return (* iface->get_selected_children) (self); +} + +/** + * gd_main_box_generic_get_selection_mode: + * @self: + * + * Returns: (transfer none): Whether @self is in selection mode + */ +gboolean +gd_main_box_generic_get_selection_mode (GdMainBoxGeneric *self) +{ + gboolean selection_mode; + + g_return_val_if_fail (GD_IS_MAIN_BOX_GENERIC (self), FALSE); + + g_object_get (self, "gd-selection-mode", &selection_mode, NULL); + return selection_mode; +} + +/** + * gd_main_box_generic_get_show_primary_text: + * @self: + * + * Returns: (transfer none): Whether @self is going to show the + * primary-text of each #GdMainBoxItem + */ +gboolean +gd_main_box_generic_get_show_primary_text (GdMainBoxGeneric *self) +{ + gboolean show_primary_text; + + g_return_val_if_fail (GD_IS_MAIN_BOX_GENERIC (self), FALSE); + + g_object_get (self, "show-primary-text", &show_primary_text, NULL); + return show_primary_text; +} + +/** + * gd_main_box_generic_get_show_secondary_text: + * @self: + * + * Returns: (transfer none): Whether @self is going to show the + * secondary-text of each #GdMainBoxItem + */ +gboolean +gd_main_box_generic_get_show_secondary_text (GdMainBoxGeneric *self) +{ + gboolean show_secondary_text; + + g_return_val_if_fail (GD_IS_MAIN_BOX_GENERIC (self), FALSE); + + g_object_get (self, "show-secondary-text", &show_secondary_text, NULL); + return show_secondary_text; +} + +void +gd_main_box_generic_select_all (GdMainBoxGeneric *self) +{ + GdMainBoxGenericInterface *iface; + + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + (* iface->select_all) (self); +} + +void +gd_main_box_generic_select_child (GdMainBoxGeneric *self, GdMainBoxChild *child) +{ + GdMainBoxGenericInterface *iface; + + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + g_return_if_fail (GD_IS_MAIN_BOX_CHILD (child)); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + (* iface->select_child) (self, child); +} + +/** + * gd_main_box_generic_set_model: + * @self: + * @model: (allow-none): + * + */ +void +gd_main_box_generic_set_model (GdMainBoxGeneric *self, GListModel *model) +{ + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + g_return_if_fail (model == NULL || G_IS_LIST_MODEL (model)); + + g_object_set (self, "model", model, NULL); +} + +/** + * gd_main_box_generic_set_selection_mode: + * @self: + * @selection_mode: + * + */ +void +gd_main_box_generic_set_selection_mode (GdMainBoxGeneric *self, gboolean selection_mode) +{ + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + g_object_set (self, "gd-selection-mode", selection_mode, NULL); +} + +/** + * gd_main_box_generic_set_show_primary_text: + * @self: + * @show_primary_text: + * + */ +void +gd_main_box_generic_set_show_primary_text (GdMainBoxGeneric *self, gboolean show_primary_text) +{ + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + g_object_set (self, "show-primary-text", show_primary_text, NULL); +} + +/** + * gd_main_box_generic_set_show_secondary_text: + * @self: + * @show_secondary_text: + * + */ +void +gd_main_box_generic_set_show_secondary_text (GdMainBoxGeneric *self, gboolean show_secondary_text) +{ + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + g_object_set (self, "show-secondary-text", show_secondary_text, NULL); +} + +void +gd_main_box_generic_unselect_all (GdMainBoxGeneric *self) +{ + GdMainBoxGenericInterface *iface; + + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + (* iface->unselect_all) (self); +} + +void +gd_main_box_generic_unselect_child (GdMainBoxGeneric *self, GdMainBoxChild *child) +{ + GdMainBoxGenericInterface *iface; + + g_return_if_fail (GD_IS_MAIN_BOX_GENERIC (self)); + g_return_if_fail (GD_IS_MAIN_BOX_CHILD (child)); + + iface = GD_MAIN_BOX_GENERIC_GET_IFACE (self); + + (* iface->unselect_child) (self, child); +} + +void +gd_main_box_generic_toggle_selection_for_child (GdMainBoxGeneric *self, + GdMainBoxChild *child, + gboolean select_range) +{ + GListModel *model; + + model = gd_main_box_generic_get_model (self); + if (model == NULL) + return; + + if (gd_main_box_child_get_selected (child)) + { + gd_main_box_generic_unselect_child (self, child); + } + else + { + if (select_range) + gd_main_box_generic_select_range (self, child); + else + gd_main_box_generic_select_child (self, child); + } +} diff --git a/subprojects/libgd/libgd/gd-main-box-generic.h b/subprojects/libgd/libgd/gd-main-box-generic.h new file mode 100644 index 0000000..2c9c805 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box-generic.h @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2016, 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#ifndef __GD_MAIN_BOX_GENERIC_H__ +#define __GD_MAIN_BOX_GENERIC_H__ + +#include +#include + +#include "gd-main-box-child.h" + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_BOX_GENERIC gd_main_box_generic_get_type() +G_DECLARE_INTERFACE (GdMainBoxGeneric, gd_main_box_generic, GD, MAIN_BOX_GENERIC, GtkWidget) + +struct _GdMainBoxGenericInterface +{ + GTypeInterface base_iface; + + /* vtable */ + GdMainBoxChild * (* get_child_at_index) (GdMainBoxGeneric *self, gint index); + const gchar * (* get_last_selected_id) (GdMainBoxGeneric *self); + GListModel * (* get_model) (GdMainBoxGeneric *self); + GList * (* get_selected_children) (GdMainBoxGeneric *self); + void (* select_all) (GdMainBoxGeneric *self); + void (* select_child) (GdMainBoxGeneric *self, GdMainBoxChild *child); + void (* unselect_all) (GdMainBoxGeneric *self); + void (* unselect_child) (GdMainBoxGeneric *self, GdMainBoxChild *child); +}; + +GdMainBoxChild * gd_main_box_generic_get_child_at_index (GdMainBoxGeneric *self, gint index); +const gchar * gd_main_box_generic_get_last_selected_id (GdMainBoxGeneric *self); +GListModel * gd_main_box_generic_get_model (GdMainBoxGeneric *self); +GList * gd_main_box_generic_get_selected_children (GdMainBoxGeneric *self); +gboolean gd_main_box_generic_get_selection_mode (GdMainBoxGeneric *self); +gboolean gd_main_box_generic_get_show_primary_text (GdMainBoxGeneric *self); +gboolean gd_main_box_generic_get_show_secondary_text (GdMainBoxGeneric *self); +void gd_main_box_generic_select_all (GdMainBoxGeneric *self); +void gd_main_box_generic_select_child (GdMainBoxGeneric *self, GdMainBoxChild *child); +void gd_main_box_generic_set_model (GdMainBoxGeneric *self, GListModel *model); +void gd_main_box_generic_set_selection_mode (GdMainBoxGeneric *self, gboolean selection_mode); +void gd_main_box_generic_set_show_primary_text (GdMainBoxGeneric *self, gboolean show_primary_text); +void gd_main_box_generic_set_show_secondary_text (GdMainBoxGeneric *self, + gboolean show_secondary_text); +void gd_main_box_generic_unselect_all (GdMainBoxGeneric *self); +void gd_main_box_generic_unselect_child (GdMainBoxGeneric *self, GdMainBoxChild *child); + +void gd_main_box_generic_toggle_selection_for_child (GdMainBoxGeneric *self, + GdMainBoxChild *child, + gboolean select_range); + +G_END_DECLS + +#endif /* __GD_MAIN_BOX_GENERIC_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-box-item.c b/subprojects/libgd/libgd/gd-main-box-item.c new file mode 100644 index 0000000..042b0e4 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box-item.c @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#include + +#include "gd-main-box-item.h" + +G_DEFINE_INTERFACE (GdMainBoxItem, gd_main_box_item, G_TYPE_OBJECT) + +static void +gd_main_box_item_default_init (GdMainBoxItemInterface *iface) +{ + GParamSpec *pspec; + + /** + * GdMainBoxItem:id: + * + * A unique ID to identify the #GdMainBoxItem object. + */ + pspec = g_param_spec_string ("id", + "ID", + "A unique ID to identify the item", + NULL, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxItem:uri: + * + * A URI corresponding to the #GdMainBoxItem object. + */ + pspec = g_param_spec_string ("uri", + "URI", + "A URI corresponding to the item", + NULL, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxItem:primary-text: + * + * Some text to describe the #GdMainBoxItem object. + */ + pspec = g_param_spec_string ("primary-text", + "Primary Text", + "Some text to describe the item", + NULL, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxItem:secondary-text: + * + * Some additional text to describe the #GdMainBoxItem object. + */ + pspec = g_param_spec_string ("secondary-text", + "Secondary Text", + "Some additional text to describe the item", + NULL, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxItem:icon: + * + * An icon to visually identify the #GdMainBoxItem object. + */ + pspec = g_param_spec_boxed ("icon", + "Icon", + "An icon to visually identify the item", + CAIRO_GOBJECT_TYPE_SURFACE, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxItem:mtime: + * + * The time when the #GdMainBoxItem object was last modified. + */ + pspec = g_param_spec_int64 ("mtime", + "Modification time", + "The time when the item was last modified", + -1, + G_MAXINT64, + -1, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); + + /** + * GdMainBoxItem:pulse: + * + * Whether to show a progress indicator. + */ + pspec = g_param_spec_boolean ("pulse", + "Pulse", + "Whether to show a progress indicator", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_interface_install_property (iface, pspec); +} + +/** + * gd_main_box_item_get_id: + * @self: + * + * Returns: (transfer none): The ID + */ +const gchar * +gd_main_box_item_get_id (GdMainBoxItem *self) +{ + GdMainBoxItemInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (self), NULL); + + iface = GD_MAIN_BOX_ITEM_GET_IFACE (self); + + return (* iface->get_id) (self); +} + +/** + * gd_main_box_item_get_uri: + * @self: + * + * Returns: (transfer none): The URI + */ +const gchar * +gd_main_box_item_get_uri (GdMainBoxItem *self) +{ + GdMainBoxItemInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (self), NULL); + + iface = GD_MAIN_BOX_ITEM_GET_IFACE (self); + + return (* iface->get_uri) (self); +} + +/** + * gd_main_box_item_get_primary_text: + * @self: + * + * Returns: (transfer none): The primary text + */ +const gchar * +gd_main_box_item_get_primary_text (GdMainBoxItem *self) +{ + GdMainBoxItemInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (self), NULL); + + iface = GD_MAIN_BOX_ITEM_GET_IFACE (self); + + return (* iface->get_primary_text) (self); +} + +/** + * gd_main_box_item_get_secondary_text: + * @self: + * + * Returns: (transfer none): The secondary text + */ +const gchar * +gd_main_box_item_get_secondary_text (GdMainBoxItem *self) +{ + GdMainBoxItemInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (self), NULL); + + iface = GD_MAIN_BOX_ITEM_GET_IFACE (self); + + return (* iface->get_secondary_text) (self); +} + +/** + * gd_main_box_item_get_icon: + * @self: + * + * Returns: (transfer none): The icon + */ +cairo_surface_t * +gd_main_box_item_get_icon (GdMainBoxItem *self) +{ + GdMainBoxItemInterface *iface; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (self), NULL); + + iface = GD_MAIN_BOX_ITEM_GET_IFACE (self); + + return (* iface->get_icon) (self); +} + +/** + * gd_main_box_item_get_mtime: + * @self: + * + * Returns: (transfer none): The modification time + */ +gint64 +gd_main_box_item_get_mtime (GdMainBoxItem *self) +{ + gint64 mtime; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (self), -1); + + g_object_get (self, "mtime", &mtime, NULL); + return mtime; +} + +/** + * gd_main_box_item_get_pulse: + * @self: + * + * Returns: (transfer none): Whether to show a progress indicator + */ +gboolean +gd_main_box_item_get_pulse (GdMainBoxItem *self) +{ + gboolean pulse; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (self), FALSE); + + g_object_get (self, "pulse", &pulse, NULL); + return pulse; +} diff --git a/subprojects/libgd/libgd/gd-main-box-item.h b/subprojects/libgd/libgd/gd-main-box-item.h new file mode 100644 index 0000000..e37cb07 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box-item.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#ifndef __GD_MAIN_BOX_ITEM_H__ +#define __GD_MAIN_BOX_ITEM_H__ + +#include +#include + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_BOX_ITEM gd_main_box_item_get_type() +G_DECLARE_INTERFACE (GdMainBoxItem, gd_main_box_item, GD, MAIN_BOX_ITEM, GObject) + +struct _GdMainBoxItemInterface +{ + GTypeInterface base_iface; + + /* vtable */ + const gchar * (* get_id) (GdMainBoxItem *self); + const gchar * (* get_uri) (GdMainBoxItem *self); + const gchar * (* get_primary_text) (GdMainBoxItem *self); + const gchar * (* get_secondary_text) (GdMainBoxItem *self); + cairo_surface_t * (* get_icon) (GdMainBoxItem *self); +}; + +const gchar * gd_main_box_item_get_id (GdMainBoxItem *self); +const gchar * gd_main_box_item_get_uri (GdMainBoxItem *self); +const gchar * gd_main_box_item_get_primary_text (GdMainBoxItem *self); +const gchar * gd_main_box_item_get_secondary_text (GdMainBoxItem *self); +cairo_surface_t * gd_main_box_item_get_icon (GdMainBoxItem *self); +gint64 gd_main_box_item_get_mtime (GdMainBoxItem *self); +gboolean gd_main_box_item_get_pulse (GdMainBoxItem *self); + +G_END_DECLS + +#endif /* __GD_MAIN_BOX_ITEM_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-box.c b/subprojects/libgd/libgd/gd-main-box.c new file mode 100644 index 0000000..be87b1d --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box.c @@ -0,0 +1,548 @@ +/* + * Copyright (c) 2016, 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#include "gd-main-box.h" +#include "gd-main-box-child.h" +#include "gd-main-box-generic.h" +#include "gd-main-icon-box.h" + +#define MAIN_BOX_TYPE_INITIAL -1 + +typedef struct _GdMainBoxPrivate GdMainBoxPrivate; + +struct _GdMainBoxPrivate +{ + GListModel *model; + GdMainBoxType current_type; + GtkWidget *current_box; + GtkWidget *frame; + gboolean selection_mode; + gboolean show_primary_text; + gboolean show_secondary_text; +}; + +enum +{ + PROP_BOX_TYPE = 1, + PROP_SELECTION_MODE, + PROP_SHOW_PRIMARY_TEXT, + PROP_SHOW_SECONDARY_TEXT, + PROP_MODEL, + NUM_PROPERTIES +}; + +enum +{ + ITEM_ACTIVATED, + SELECTION_CHANGED, + SELECTION_MODE_REQUEST, + NUM_SIGNALS +}; + +static GParamSpec *properties[NUM_PROPERTIES] = { NULL, }; +static guint signals[NUM_SIGNALS] = { 0, }; + +G_DEFINE_TYPE_WITH_PRIVATE (GdMainBox, gd_main_box, GTK_TYPE_BIN) + +static void +gd_main_box_activate_item_for_child (GdMainBox *self, GdMainBoxChild *child) +{ + GdMainBoxPrivate *priv; + GdMainBoxItem *item; + + priv = gd_main_box_get_instance_private (self); + + if (priv->model == NULL) + return; + + item = gd_main_box_child_get_item (child); + if (item == NULL) + return; + + g_signal_emit (self, signals[ITEM_ACTIVATED], 0, item); +} + +static void +gd_main_box_apply_selection_mode (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + gd_main_box_generic_set_selection_mode (GD_MAIN_BOX_GENERIC (priv->current_box), priv->selection_mode); + + if (!priv->selection_mode) + { + if (priv->model != NULL) + gd_main_box_unselect_all (self); + } +} + +static void +gd_main_box_item_activated_cb (GdMainBox *self, GdMainBoxChild *child) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + if (!priv->selection_mode) + gd_main_box_activate_item_for_child (self, child); +} + +static void +gd_main_box_selection_changed_cb (GdMainBox *self) +{ + g_signal_emit (self, signals[SELECTION_CHANGED], 0); +} + +static void +gd_main_box_selection_mode_request_cb (GdMainBox *self) +{ + g_signal_emit (self, signals[SELECTION_MODE_REQUEST], 0); +} + +static void +gd_main_box_rebuild (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + if (priv->current_box != NULL) + gtk_widget_destroy (priv->current_box); + + switch (priv->current_type) + { + case GD_MAIN_BOX_ICON: + priv->current_box = gd_main_icon_box_new (); + break; + + case GD_MAIN_BOX_LIST: + default: + g_assert_not_reached (); + break; + } + + gtk_widget_set_hexpand (priv->current_box, TRUE); + gtk_widget_set_valign (priv->current_box, GTK_ALIGN_START); + g_object_bind_property (self, "show-primary-text", + priv->current_box, "show-primary-text", + G_BINDING_SYNC_CREATE); + g_object_bind_property (self, "show-secondary-text", + priv->current_box, "show-secondary-text", + G_BINDING_SYNC_CREATE); + gtk_container_add (GTK_CONTAINER (priv->frame), priv->current_box); + + g_signal_connect_swapped (priv->current_box, + "item-activated", + G_CALLBACK (gd_main_box_item_activated_cb), + self); + g_signal_connect_swapped (priv->current_box, + "selection-changed", + G_CALLBACK (gd_main_box_selection_changed_cb), + self); + g_signal_connect_swapped (priv->current_box, + "selection-mode-request", + G_CALLBACK (gd_main_box_selection_mode_request_cb), + self); + + gd_main_box_generic_set_model (GD_MAIN_BOX_GENERIC (priv->current_box), priv->model); + gd_main_box_apply_selection_mode (self); + + gtk_widget_show_all (GTK_WIDGET (self)); +} + +static void +gd_main_box_dispose (GObject *obj) +{ + GdMainBox *self = GD_MAIN_BOX (obj); + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + g_clear_object (&priv->model); + + G_OBJECT_CLASS (gd_main_box_parent_class)->dispose (obj); +} + +static void +gd_main_box_init (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + GtkStyleContext *context; + + priv = gd_main_box_get_instance_private (self); + + priv->frame = gtk_frame_new (NULL); + context = gtk_widget_get_style_context (priv->frame); + gtk_style_context_add_class (context, "content-view"); + gtk_container_add (GTK_CONTAINER (self), priv->frame); + + /* so that we get constructed with the right view even at startup */ + priv->current_type = MAIN_BOX_TYPE_INITIAL; +} + +static void +gd_main_box_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + GdMainBox *self = GD_MAIN_BOX (object); + + switch (property_id) + { + case PROP_BOX_TYPE: + g_value_set_int (value, gd_main_box_get_box_type (self)); + break; + case PROP_SELECTION_MODE: + g_value_set_boolean (value, gd_main_box_get_selection_mode (self)); + break; + case PROP_SHOW_PRIMARY_TEXT: + g_value_set_boolean (value, gd_main_box_get_show_primary_text (self)); + break; + case PROP_SHOW_SECONDARY_TEXT: + g_value_set_boolean (value, gd_main_box_get_show_secondary_text (self)); + break; + case PROP_MODEL: + g_value_set_object (value, gd_main_box_get_model (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_box_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + GdMainBox *self = GD_MAIN_BOX (object); + + switch (property_id) + { + case PROP_BOX_TYPE: + gd_main_box_set_box_type (self, g_value_get_int (value)); + break; + case PROP_SELECTION_MODE: + gd_main_box_set_selection_mode (self, g_value_get_boolean (value)); + break; + case PROP_SHOW_PRIMARY_TEXT: + gd_main_box_set_show_primary_text (self, g_value_get_boolean (value)); + break; + case PROP_SHOW_SECONDARY_TEXT: + gd_main_box_set_show_secondary_text (self, g_value_get_boolean (value)); + break; + case PROP_MODEL: + gd_main_box_set_model (self, g_value_get_object (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_box_class_init (GdMainBoxClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->get_property = gd_main_box_get_property; + oclass->set_property = gd_main_box_set_property; + oclass->dispose = gd_main_box_dispose; + + properties[PROP_BOX_TYPE] = g_param_spec_int ("box-type", + "Box type", + "Box type", + GD_MAIN_BOX_ICON, + GD_MAIN_BOX_LIST, + GD_MAIN_BOX_ICON, + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + properties[PROP_MODEL] = g_param_spec_object ("model", + "Model", + "The GListModel", + G_TYPE_LIST_MODEL, + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + properties[PROP_SELECTION_MODE] = g_param_spec_boolean ("selection-mode", + "Selection mode", + "Whether the view is in selection mode", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + properties[PROP_SHOW_PRIMARY_TEXT] = g_param_spec_boolean ("show-primary-text", + "Show primary text", + "Whether each GdMainBoxItem's primary-text is going " + "to be shown", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + properties[PROP_SHOW_SECONDARY_TEXT] = g_param_spec_boolean ("show-secondary-text", + "Show secondary text", + "Whether each GdMainBoxItem's secondary-text is " + "going to be shown", + FALSE, + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + signals[ITEM_ACTIVATED] = g_signal_new ("item-activated", + GD_TYPE_MAIN_BOX, + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, + 1, + GD_TYPE_MAIN_BOX_ITEM); + + signals[SELECTION_CHANGED] = g_signal_new ("selection-changed", + GD_TYPE_MAIN_BOX, + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + signals[SELECTION_MODE_REQUEST] = g_signal_new ("selection-mode-request", + GD_TYPE_MAIN_BOX, + G_SIGNAL_RUN_LAST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + g_object_class_install_properties (oclass, NUM_PROPERTIES, properties); +} + +GtkWidget * +gd_main_box_new (GdMainBoxType type) +{ + return g_object_new (GD_TYPE_MAIN_BOX, "box-type", type, NULL); +} + +GdMainBoxType +gd_main_box_get_box_type (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + return priv->current_type; +} + +void +gd_main_box_set_box_type (GdMainBox *self, GdMainBoxType type) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + if (type == priv->current_type) + return; + + priv->current_type = type; + gd_main_box_rebuild (self); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_BOX_TYPE]); +} + +gboolean +gd_main_box_get_selection_mode (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + return priv->selection_mode; +} + +gboolean +gd_main_box_get_show_primary_text (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + return priv->show_primary_text; +} + +gboolean +gd_main_box_get_show_secondary_text (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + return priv->show_secondary_text; +} + +void +gd_main_box_set_selection_mode (GdMainBox *self, gboolean selection_mode) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + if (selection_mode == priv->selection_mode) + return; + + priv->selection_mode = selection_mode; + gd_main_box_apply_selection_mode (self); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SELECTION_MODE]); +} + +void +gd_main_box_set_show_primary_text (GdMainBox *self, gboolean show_primary_text) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + if (show_primary_text == priv->show_primary_text) + return; + + priv->show_primary_text = show_primary_text; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SHOW_PRIMARY_TEXT]); +} + +void +gd_main_box_set_show_secondary_text (GdMainBox *self, gboolean show_secondary_text) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + if (show_secondary_text == priv->show_secondary_text) + return; + + priv->show_secondary_text = show_secondary_text; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SHOW_SECONDARY_TEXT]); +} + +/** + * gd_main_box_get_model: + * @self: + * + * Returns: (transfer none): + */ +GListModel * +gd_main_box_get_model (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + return priv->model; +} + +/** + * gd_main_box_set_model: + * @self: + * @model: (allow-none): + * + */ +void +gd_main_box_set_model (GdMainBox *self, GListModel *model) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + + if (!g_set_object (&priv->model, model)) + return; + + gd_main_box_generic_set_model (GD_MAIN_BOX_GENERIC (priv->current_box), priv->model); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MODEL]); +} + +/** + * gd_main_box_get_generic_box: + * @self: + * + * Returns: (transfer none): + */ +GtkWidget * +gd_main_box_get_generic_box (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + return priv->current_box; +} + +/** + * gd_main_box_get_selection: + * @self: + * + * Returns: (element-type GdMainBoxItem) (transfer full): + */ +GList * +gd_main_box_get_selection (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + GList *l; + GList *selected_children; + GList *selection = NULL; + + priv = gd_main_box_get_instance_private (self); + + selected_children = gd_main_box_generic_get_selected_children (GD_MAIN_BOX_GENERIC (priv->current_box)); + for (l = selected_children; l != NULL; l = l->next) + { + GdMainBoxChild *child = GD_MAIN_BOX_CHILD (l->data); + GdMainBoxItem *item; + + item = gd_main_box_child_get_item (child); + selection = g_list_prepend (selection, g_object_ref (item)); + } + + selection = g_list_reverse (selection); + g_list_free (selected_children); + return selection; +} + +void +gd_main_box_select_all (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + gd_main_box_generic_select_all (GD_MAIN_BOX_GENERIC (priv->current_box)); +} + +void +gd_main_box_unselect_all (GdMainBox *self) +{ + GdMainBoxPrivate *priv; + + priv = gd_main_box_get_instance_private (self); + gd_main_box_generic_unselect_all (GD_MAIN_BOX_GENERIC (priv->current_box)); +} diff --git a/subprojects/libgd/libgd/gd-main-box.h b/subprojects/libgd/libgd/gd-main-box.h new file mode 100644 index 0000000..1ff8038 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-box.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2016, 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#ifndef __GD_MAIN_BOX_H__ +#define __GD_MAIN_BOX_H__ + +#include +#include + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_BOX gd_main_box_get_type() +G_DECLARE_DERIVABLE_TYPE (GdMainBox, gd_main_box, GD, MAIN_BOX, GtkBin) + +typedef enum +{ + GD_MAIN_BOX_ICON, + GD_MAIN_BOX_LIST +} GdMainBoxType; + +struct _GdMainBoxClass +{ + GtkBinClass parent_class; +}; + +GtkWidget * gd_main_box_new (GdMainBoxType type); +GdMainBoxType gd_main_box_get_box_type (GdMainBox *self); +GListModel * gd_main_box_get_model (GdMainBox *self); +GList * gd_main_box_get_selection (GdMainBox *self); +gboolean gd_main_box_get_selection_mode (GdMainBox *self); +gboolean gd_main_box_get_show_primary_text (GdMainBox *self); +gboolean gd_main_box_get_show_secondary_text (GdMainBox *self); +void gd_main_box_select_all (GdMainBox *self); +void gd_main_box_set_box_type (GdMainBox *self, GdMainBoxType type); +void gd_main_box_set_model (GdMainBox *self, GListModel *model); +void gd_main_box_set_selection_mode (GdMainBox *self, gboolean selection_mode); +void gd_main_box_set_show_primary_text (GdMainBox *self, gboolean show_primary_text); +void gd_main_box_set_show_secondary_text (GdMainBox *self, gboolean show_secondary_text); +void gd_main_box_unselect_all (GdMainBox *self); + +G_END_DECLS + +#endif /* __GD_MAIN_BOX_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-icon-box-child.c b/subprojects/libgd/libgd/gd-main-icon-box-child.c new file mode 100644 index 0000000..3e24694 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-box-child.c @@ -0,0 +1,439 @@ +/* + * Copyright (c) 2016, 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#include "gd-main-box-child.h" +#include "gd-main-icon-box-child.h" +#include "gd-main-icon-box-icon.h" + +#include +#include + +typedef struct _GdMainIconBoxChildPrivate GdMainIconBoxChildPrivate; + +struct _GdMainIconBoxChildPrivate +{ + GdMainBoxItem *item; + GtkWidget *check_button; + gboolean selection_mode; + gboolean show_primary_text; + gboolean show_secondary_text; +}; + +enum +{ + PROP_ITEM = 1, + PROP_SELECTION_MODE, + PROP_SHOW_PRIMARY_TEXT, + PROP_SHOW_SECONDARY_TEXT, + NUM_PROPERTIES +}; + +static void gd_main_box_child_interface_init (GdMainBoxChildInterface *iface); +G_DEFINE_TYPE_WITH_CODE (GdMainIconBoxChild, gd_main_icon_box_child, GTK_TYPE_FLOW_BOX_CHILD, + G_ADD_PRIVATE (GdMainIconBoxChild) + G_IMPLEMENT_INTERFACE (GD_TYPE_MAIN_BOX_CHILD, gd_main_box_child_interface_init)) + +static gboolean +gd_main_icon_box_child_bind_text_to_visible (GBinding *binding, + const GValue *from_value, + GValue *to_value, + gpointer user_data) +{ + gboolean to_visible; + const gchar *from_text; + + from_text = g_value_get_string (from_value); + to_visible = from_text != NULL && from_text[0] != '\0' ? TRUE : FALSE; + g_value_set_boolean (to_value, to_visible); + return TRUE; +} + +static void +gd_main_icon_box_check_button_toggled (GdMainIconBoxChild *self) +{ + GdMainIconBoxChildPrivate *priv; + GtkWidget *parent; + + priv = gd_main_icon_box_child_get_instance_private (self); + + parent = gtk_widget_get_parent (GTK_WIDGET (self)); + if (!GTK_IS_FLOW_BOX (parent)) + return; + + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->check_button))) + gtk_flow_box_select_child (GTK_FLOW_BOX (parent), GTK_FLOW_BOX_CHILD (self)); + else + gtk_flow_box_unselect_child (GTK_FLOW_BOX (parent), GTK_FLOW_BOX_CHILD (self)); +} + +static void +gd_main_icon_box_child_update_layout (GdMainIconBoxChild *self) +{ + GdMainIconBoxChildPrivate *priv; + GtkWidget *grid; + GtkWidget *icon; + GtkWidget *overlay; + + priv = gd_main_icon_box_child_get_instance_private (self); + + gtk_container_foreach (GTK_CONTAINER (self), (GtkCallback) gtk_widget_destroy, NULL); + + grid = gtk_grid_new (); + gtk_widget_set_valign (grid, GTK_ALIGN_CENTER); + gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL); + gtk_container_add (GTK_CONTAINER (self), grid); + + overlay = gtk_overlay_new (); + gtk_container_add (GTK_CONTAINER (grid), overlay); + + icon = gd_main_icon_box_icon_new (priv->item); + gtk_widget_set_hexpand (icon, TRUE); + gtk_container_add (GTK_CONTAINER (overlay), icon); + + if (gd_main_box_item_get_pulse (priv->item)) + { + GtkWidget *spinner; + + spinner = gtk_spinner_new (); + gtk_widget_set_halign (spinner, GTK_ALIGN_CENTER); + gtk_widget_set_size_request (spinner, 32, 32); + gtk_widget_set_valign (spinner, GTK_ALIGN_CENTER); + gtk_spinner_start (GTK_SPINNER (spinner)); + gtk_overlay_add_overlay (GTK_OVERLAY (overlay), spinner); + } + + priv->check_button = gtk_check_button_new (); + gtk_widget_set_can_focus (priv->check_button, FALSE); + gtk_widget_set_halign (priv->check_button, GTK_ALIGN_END); + gtk_widget_set_valign (priv->check_button, GTK_ALIGN_END); + gtk_widget_set_no_show_all (priv->check_button, TRUE); + g_object_bind_property (self, "selection-mode", priv->check_button, "visible", G_BINDING_SYNC_CREATE); + gtk_overlay_add_overlay (GTK_OVERLAY (overlay), priv->check_button); + g_signal_connect_swapped (priv->check_button, + "toggled", + G_CALLBACK (gd_main_icon_box_check_button_toggled), + self); + + if (priv->show_primary_text) + { + GtkWidget *primary_label; + + primary_label = gtk_label_new (NULL); + gtk_widget_set_no_show_all (primary_label, TRUE); + gtk_label_set_ellipsize (GTK_LABEL (primary_label), PANGO_ELLIPSIZE_MIDDLE); + g_object_bind_property (priv->item, "primary-text", primary_label, "label", G_BINDING_SYNC_CREATE); + g_object_bind_property_full (priv->item, + "primary-text", + primary_label, + "visible", + G_BINDING_SYNC_CREATE, + gd_main_icon_box_child_bind_text_to_visible, + NULL, + NULL, + NULL); + gtk_container_add (GTK_CONTAINER (grid), primary_label); + } + + if (priv->show_secondary_text) + { + GtkStyleContext *context; + GtkWidget *secondary_label; + + secondary_label = gtk_label_new (NULL); + gtk_widget_set_no_show_all (secondary_label, TRUE); + gtk_label_set_ellipsize (GTK_LABEL (secondary_label), PANGO_ELLIPSIZE_END); + context = gtk_widget_get_style_context (secondary_label); + gtk_style_context_add_class (context, "dim-label"); + g_object_bind_property (priv->item, "secondary-text", secondary_label, "label", G_BINDING_SYNC_CREATE); + g_object_bind_property_full (priv->item, + "secondary-text", + secondary_label, + "visible", + G_BINDING_SYNC_CREATE, + gd_main_icon_box_child_bind_text_to_visible, + NULL, + NULL, + NULL); + gtk_container_add (GTK_CONTAINER (grid), secondary_label); + } + + gtk_widget_show_all (grid); +} + +static void +gd_main_icon_box_child_notify_pulse (GdMainIconBoxChild *self) +{ + gd_main_icon_box_child_update_layout (self); +} + +static GdMainBoxItem * +gd_main_icon_box_child_get_item (GdMainBoxChild *child) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (child); + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + return priv->item; +} + +static gint +gd_main_icon_box_child_get_index (GdMainBoxChild *child) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (child); + gint index; + + index = gtk_flow_box_child_get_index (GTK_FLOW_BOX_CHILD (self)); + return index; +} + +static gboolean +gd_main_icon_box_child_get_selected (GdMainBoxChild *child) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (child); + gboolean selected; + + selected = gtk_flow_box_child_is_selected (GTK_FLOW_BOX_CHILD (self)); + return selected; +} + +static gboolean +gd_main_icon_box_child_get_selection_mode (GdMainIconBoxChild *self) +{ + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + return priv->selection_mode; +} + +static gboolean +gd_main_icon_box_child_get_show_primary_text (GdMainIconBoxChild *self) +{ + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + return priv->show_primary_text; +} + +static gboolean +gd_main_icon_box_child_get_show_secondary_text (GdMainIconBoxChild *self) +{ + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + return priv->show_secondary_text; +} + +static void +gd_main_icon_box_child_set_item (GdMainIconBoxChild *self, GdMainBoxItem *item) +{ + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + + if (priv->item != NULL) + g_signal_handlers_disconnect_by_func (priv->item, gd_main_icon_box_child_notify_pulse, self); + + if (!g_set_object (&priv->item, item)) + return; + + if (priv->item != NULL) + { + g_signal_connect_object (priv->item, + "notify::pulse", + G_CALLBACK (gd_main_icon_box_child_notify_pulse), + self, + G_CONNECT_SWAPPED); + } + + g_object_notify (G_OBJECT (self), "item"); + gtk_widget_queue_draw (GTK_WIDGET (self)); +} + +static void +gd_main_icon_box_child_set_selected (GdMainBoxChild *child, gboolean selected) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (child); + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_button), selected); +} + +static void +gd_main_icon_box_child_set_selection_mode (GdMainIconBoxChild *self, gboolean selection_mode) +{ + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + + if (priv->selection_mode == selection_mode) + return; + + priv->selection_mode = selection_mode; + g_object_notify (G_OBJECT (self), "selection-mode"); + gtk_widget_queue_draw (GTK_WIDGET (self)); +} + +static void +gd_main_icon_box_child_set_show_primary_text (GdMainIconBoxChild *self, gboolean show_primary_text) +{ + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + + if (priv->show_primary_text == show_primary_text) + return; + + priv->show_primary_text = show_primary_text; + gd_main_icon_box_child_update_layout (self); + g_object_notify (G_OBJECT (self), "show-primary-text"); +} + +static void +gd_main_icon_box_child_set_show_secondary_text (GdMainIconBoxChild *self, gboolean show_secondary_text) +{ + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + + if (priv->show_secondary_text == show_secondary_text) + return; + + priv->show_secondary_text = show_secondary_text; + gd_main_icon_box_child_update_layout (self); + g_object_notify (G_OBJECT (self), "show-secondary-text"); +} + +static void +gd_main_icon_box_child_constructed (GObject *obj) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (obj); + + G_OBJECT_CLASS (gd_main_icon_box_child_parent_class)->constructed (obj); + + gd_main_icon_box_child_update_layout (self); +} + +static void +gd_main_icon_box_child_dispose (GObject *obj) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (obj); + GdMainIconBoxChildPrivate *priv; + + priv = gd_main_icon_box_child_get_instance_private (self); + + g_clear_object (&priv->item); + + G_OBJECT_CLASS (gd_main_icon_box_child_parent_class)->dispose (obj); +} + +static void +gd_main_icon_box_child_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (object); + + switch (property_id) + { + case PROP_ITEM: + g_value_set_object (value, gd_main_icon_box_child_get_item (GD_MAIN_BOX_CHILD (self))); + break; + case PROP_SELECTION_MODE: + g_value_set_boolean (value, gd_main_icon_box_child_get_selection_mode (self)); + break; + case PROP_SHOW_PRIMARY_TEXT: + g_value_set_boolean (value, gd_main_icon_box_child_get_show_primary_text (self)); + break; + case PROP_SHOW_SECONDARY_TEXT: + g_value_set_boolean (value, gd_main_icon_box_child_get_show_secondary_text (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_icon_box_child_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + GdMainIconBoxChild *self = GD_MAIN_ICON_BOX_CHILD (object); + + switch (property_id) + { + case PROP_ITEM: + gd_main_icon_box_child_set_item (self, g_value_get_object (value)); + break; + case PROP_SELECTION_MODE: + gd_main_icon_box_child_set_selection_mode (self, g_value_get_boolean (value)); + break; + case PROP_SHOW_PRIMARY_TEXT: + gd_main_icon_box_child_set_show_primary_text (self, g_value_get_boolean (value)); + break; + case PROP_SHOW_SECONDARY_TEXT: + gd_main_icon_box_child_set_show_secondary_text (self, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_icon_box_child_init (GdMainIconBoxChild *self) +{ + GtkStyleContext *context; + + context = gtk_widget_get_style_context (GTK_WIDGET (self)); + gtk_style_context_add_class (context, "tile"); +} + +static void +gd_main_icon_box_child_class_init (GdMainIconBoxChildClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->constructed = gd_main_icon_box_child_constructed; + oclass->dispose = gd_main_icon_box_child_dispose; + oclass->get_property = gd_main_icon_box_child_get_property; + oclass->set_property = gd_main_icon_box_child_set_property; + + g_object_class_override_property (oclass, PROP_ITEM, "item"); + g_object_class_override_property (oclass, PROP_SELECTION_MODE, "selection-mode"); + g_object_class_override_property (oclass, PROP_SHOW_PRIMARY_TEXT, "show-primary-text"); + g_object_class_override_property (oclass, PROP_SHOW_SECONDARY_TEXT, "show-secondary-text"); +} + +static void +gd_main_box_child_interface_init (GdMainBoxChildInterface *iface) +{ + iface->get_index = gd_main_icon_box_child_get_index; + iface->get_item = gd_main_icon_box_child_get_item; + iface->get_selected = gd_main_icon_box_child_get_selected; + iface->set_selected = gd_main_icon_box_child_set_selected; +} + +GtkWidget * +gd_main_icon_box_child_new (GdMainBoxItem *item, gboolean selection_mode) +{ + return g_object_new (GD_TYPE_MAIN_ICON_BOX_CHILD, + "item", item, + "selection-mode", selection_mode, + NULL); +} diff --git a/subprojects/libgd/libgd/gd-main-icon-box-child.h b/subprojects/libgd/libgd/gd-main-icon-box-child.h new file mode 100644 index 0000000..40eb271 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-box-child.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#ifndef __GD_MAIN_ICON_BOX_CHILD_H__ +#define __GD_MAIN_ICON_BOX_CHILD_H__ + +#include + +#include "gd-main-box-item.h" + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_ICON_BOX_CHILD gd_main_icon_box_child_get_type() +G_DECLARE_DERIVABLE_TYPE (GdMainIconBoxChild, gd_main_icon_box_child, GD, MAIN_ICON_BOX_CHILD, GtkFlowBoxChild) + +struct _GdMainIconBoxChildClass +{ + GtkFlowBoxChildClass parent_class; +}; + +GtkWidget * gd_main_icon_box_child_new (GdMainBoxItem *item, gboolean selection_mode); + +G_END_DECLS + +#endif /* __GD_MAIN_ICON_BOX_CHILD_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-icon-box-icon.c b/subprojects/libgd/libgd/gd-main-icon-box-icon.c new file mode 100644 index 0000000..54fa139 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-box-icon.c @@ -0,0 +1,366 @@ +/* + * Copyright (c) 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#include "gd-main-icon-box-icon.h" + +#include +#include + +struct _GdMainIconBoxIcon +{ + GtkDrawingArea parent_instance; + GdMainBoxItem *item; + cairo_surface_t *surface_zoomed; + gdouble x; + gdouble y; +}; + +enum +{ + PROP_ITEM = 1, + NUM_PROPERTIES +}; + +static GParamSpec *properties[NUM_PROPERTIES] = { NULL, }; + +G_DEFINE_TYPE (GdMainIconBoxIcon, gd_main_icon_box_icon, GTK_TYPE_DRAWING_AREA) + +static cairo_surface_t * +gd_zoom_image_surface (cairo_surface_t *surface, gint width_zoomed, gint height_zoomed) +{ + cairo_t *cr; + cairo_format_t format; + cairo_pattern_t *pattern; + cairo_surface_t *zoomed = NULL; + cairo_surface_type_t surface_type; + gdouble scale_x; + gdouble scale_y; + gdouble zoom_x; + gdouble zoom_y; + gint height; + gint width; + + g_return_val_if_fail (surface != NULL, NULL); + + surface_type = cairo_surface_get_type (surface); + g_return_val_if_fail (surface_type == CAIRO_SURFACE_TYPE_IMAGE, NULL); + + format = cairo_image_surface_get_format (surface); + zoomed = cairo_surface_create_similar_image (surface, format, width_zoomed, height_zoomed); + cairo_surface_get_device_scale (surface, &scale_x, &scale_y); + cairo_surface_set_device_scale (zoomed, scale_x, scale_y); + + cr = cairo_create (zoomed); + + pattern = cairo_get_source (cr); + cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REFLECT); + cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); + + height = cairo_image_surface_get_height (surface); + width = cairo_image_surface_get_width (surface); + zoom_x = (double) width_zoomed / (gdouble) width; + zoom_y = (double) height_zoomed / (gdouble) height; + cairo_scale (cr, zoom_x, zoom_y); + cairo_set_source_surface (cr, surface, 0, 0); + + cairo_paint (cr); + cairo_destroy (cr); + + return zoomed; +} + +static void +gd_main_icon_box_icon_get_preferred_size (GdMainIconBoxIcon *self, gint *minimum, gint *natural) +{ + cairo_surface_t *surface; + cairo_surface_type_t surface_type; + gint height_scaled; + gint width_scaled; + gint scale_factor; + gint size = 0; + gint size_scaled; + + surface = gd_main_box_item_get_icon (self->item); + if (surface == NULL) + goto out; + + surface_type = cairo_surface_get_type (surface); + g_return_if_fail (surface_type == CAIRO_SURFACE_TYPE_IMAGE); + + scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (self)); + height_scaled = cairo_image_surface_get_height (surface); + width_scaled = cairo_image_surface_get_width (surface); + + size_scaled = MAX (height_scaled, width_scaled); + size = size_scaled / scale_factor; + + out: + if (minimum != NULL) + *minimum = size; + + if (natural != NULL) + *natural = size; +} + +static void +gd_main_icon_box_icon_notify_icon (GdMainIconBoxIcon *self) +{ + g_clear_pointer (&self->surface_zoomed, cairo_surface_destroy); + gtk_widget_queue_resize (GTK_WIDGET (self)); +} + +static gboolean +gd_main_icon_box_icon_draw (GtkWidget *widget, cairo_t *cr) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (widget); + + if (self->surface_zoomed == NULL) + goto out; + + cairo_save (cr); + cairo_set_source_surface (cr, self->surface_zoomed, self->x, self->y); + cairo_paint (cr); + cairo_restore (cr); + + out: + return GDK_EVENT_PROPAGATE; +} + +static void +gd_main_icon_box_icon_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (widget); + gd_main_icon_box_icon_get_preferred_size (self, minimum, natural); +} + +static void +gd_main_icon_box_icon_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (widget); + gd_main_icon_box_icon_get_preferred_size (self, minimum, natural); +} + +static void +gd_main_icon_box_icon_size_allocate (GtkWidget *widget, GtkAllocation *allocation) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (widget); + cairo_surface_t *surface; + cairo_surface_type_t surface_type; + gdouble zoom; + gint allocation_height_scaled; + gint allocation_width_scaled; + gint height_scaled; + gint height_zoomed_scaled; + gint scale_factor; + gint width_scaled; + gint width_zoomed_scaled; + + GTK_WIDGET_CLASS (gd_main_icon_box_icon_parent_class)->size_allocate (widget, allocation); + + surface = gd_main_box_item_get_icon (self->item); + if (surface == NULL) + { + g_return_if_fail (self->surface_zoomed == NULL); + return; + } + + surface_type = cairo_surface_get_type (surface); + g_return_if_fail (surface_type == CAIRO_SURFACE_TYPE_IMAGE); + + scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (self)); + + allocation_height_scaled = allocation->height * scale_factor; + allocation_width_scaled = allocation->width * scale_factor; + + if (self->surface_zoomed != NULL) + { + height_zoomed_scaled = cairo_image_surface_get_height (self->surface_zoomed); + width_zoomed_scaled = cairo_image_surface_get_width (self->surface_zoomed); + if (height_zoomed_scaled == allocation_height_scaled && width_zoomed_scaled == allocation_width_scaled) + return; + } + + height_scaled = cairo_image_surface_get_height (surface); + width_scaled = cairo_image_surface_get_width (surface); + + if (height_scaled > width_scaled && allocation_height_scaled > height_scaled) + { + zoom = (gdouble) allocation_height_scaled / (gdouble) height_scaled; + height_zoomed_scaled = allocation_height_scaled; + width_zoomed_scaled = (gint) (zoom * (gdouble) width_scaled + 0.5); + + if (allocation_width_scaled < width_zoomed_scaled) + { + zoom = (gdouble) allocation_width_scaled / (gdouble) width_zoomed_scaled; + height_zoomed_scaled = (gint) (zoom * (gdouble) height_zoomed_scaled + 0.5); + width_zoomed_scaled = allocation_width_scaled; + } + } + else if (height_scaled <= width_scaled && allocation_width_scaled > width_scaled) + { + zoom = (gdouble) allocation_width_scaled / (gdouble) width_scaled; + height_zoomed_scaled = (gint) (zoom * (gdouble) height_scaled + 0.5); + width_zoomed_scaled = allocation_width_scaled; + + if (allocation_height_scaled < height_zoomed_scaled) + { + zoom = (gdouble) allocation_height_scaled / (gdouble) height_zoomed_scaled; + height_zoomed_scaled = allocation_height_scaled; + width_zoomed_scaled = (gint) (zoom * (gdouble) width_zoomed_scaled + 0.5); + } + } + else + { + height_zoomed_scaled = height_scaled; + width_zoomed_scaled = width_scaled; + } + + g_clear_pointer (&self->surface_zoomed, cairo_surface_destroy); + self->surface_zoomed = gd_zoom_image_surface (surface, width_zoomed_scaled, height_zoomed_scaled); + + self->x = (gdouble) (allocation_width_scaled - width_zoomed_scaled) / (2.0 * (gdouble) scale_factor); + self->y = (gdouble) (allocation_height_scaled - height_zoomed_scaled) / (2.0 * (gdouble) scale_factor); +} + +static void +gd_main_icon_box_icon_dispose (GObject *obj) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (obj); + + g_clear_object (&self->item); + + G_OBJECT_CLASS (gd_main_icon_box_icon_parent_class)->dispose (obj); +} + +static void +gd_main_icon_box_icon_finalize (GObject *obj) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (obj); + + g_clear_pointer (&self->surface_zoomed, cairo_surface_destroy); + + G_OBJECT_CLASS (gd_main_icon_box_icon_parent_class)->finalize (obj); +} + +static void +gd_main_icon_box_icon_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (object); + + switch (property_id) + { + case PROP_ITEM: + g_value_set_object (value, gd_main_icon_box_icon_get_item (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_icon_box_icon_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + GdMainIconBoxIcon *self = GD_MAIN_ICON_BOX_ICON (object); + + switch (property_id) + { + case PROP_ITEM: + gd_main_icon_box_icon_set_item (self, g_value_get_object (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_icon_box_icon_init (GdMainIconBoxIcon *self) +{ +} + +static void +gd_main_icon_box_icon_class_init (GdMainIconBoxIconClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + GtkWidgetClass *wclass = GTK_WIDGET_CLASS (klass); + + oclass->dispose = gd_main_icon_box_icon_dispose; + oclass->finalize = gd_main_icon_box_icon_finalize; + oclass->get_property = gd_main_icon_box_icon_get_property; + oclass->set_property = gd_main_icon_box_icon_set_property; + wclass->draw = gd_main_icon_box_icon_draw; + wclass->get_preferred_height = gd_main_icon_box_icon_get_preferred_height; + wclass->get_preferred_width = gd_main_icon_box_icon_get_preferred_width; + wclass->size_allocate = gd_main_icon_box_icon_size_allocate; + + properties[PROP_ITEM] = g_param_spec_object ("item", + "Item", + "An item that is rendered by the widget", + GD_TYPE_MAIN_BOX_ITEM, + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, NUM_PROPERTIES, properties); +} + +GtkWidget * +gd_main_icon_box_icon_new (GdMainBoxItem *item) +{ + g_return_val_if_fail (item == NULL || GD_IS_MAIN_BOX_ITEM (item), NULL); + return g_object_new (GD_TYPE_MAIN_ICON_BOX_ICON, "item", item, NULL); +} + +GdMainBoxItem * +gd_main_icon_box_icon_get_item (GdMainIconBoxIcon *self) +{ + g_return_val_if_fail (GD_IS_MAIN_ICON_BOX_ICON (self), NULL); + return self->item; +} + +void +gd_main_icon_box_icon_set_item (GdMainIconBoxIcon *self, GdMainBoxItem *item) +{ + g_return_if_fail (GD_IS_MAIN_ICON_BOX_ICON (self)); + g_return_if_fail (item == NULL || GD_IS_MAIN_BOX_ITEM (item)); + + if (self->item == item) + return; + + if (self->item != NULL) + g_signal_handlers_disconnect_by_func (self->item, gd_main_icon_box_icon_notify_icon, self); + + g_clear_pointer (&self->surface_zoomed, cairo_surface_destroy); + g_set_object (&self->item, item); + + if (self->item != NULL) + { + g_signal_connect_object (self->item, + "notify::icon", + G_CALLBACK (gd_main_icon_box_icon_notify_icon), + self, + G_CONNECT_SWAPPED); + } + + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ITEM]); + gtk_widget_queue_resize (GTK_WIDGET (self)); +} diff --git a/subprojects/libgd/libgd/gd-main-icon-box-icon.h b/subprojects/libgd/libgd/gd-main-icon-box-icon.h new file mode 100644 index 0000000..7189e0e --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-box-icon.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#ifndef __GD_MAIN_ICON_BOX_ICON_H__ +#define __GD_MAIN_ICON_BOX_ICON_H__ + +#include + +#include "gd-main-box-item.h" + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_ICON_BOX_ICON gd_main_icon_box_icon_get_type() +G_DECLARE_FINAL_TYPE (GdMainIconBoxIcon, gd_main_icon_box_icon, GD, MAIN_ICON_BOX_ICON, GtkDrawingArea) + +GtkWidget * gd_main_icon_box_icon_new (GdMainBoxItem *item); +GdMainBoxItem * gd_main_icon_box_icon_get_item (GdMainIconBoxIcon *self); +void gd_main_icon_box_icon_set_item (GdMainIconBoxIcon *self, GdMainBoxItem *item); + +G_END_DECLS + +#endif /* __GD_MAIN_ICON_BOX_ICON_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-icon-box.c b/subprojects/libgd/libgd/gd-main-icon-box.c new file mode 100644 index 0000000..1d6cdf4 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-box.c @@ -0,0 +1,1042 @@ +/* + * Copyright (c) 2016, 2017 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#include + +#include +#include + +#include "gd-icon-utils.h" +#include "gd-main-icon-box.h" +#include "gd-main-icon-box-child.h" +#include "gd-main-box-child.h" +#include "gd-main-box-generic.h" +#include "gd-main-box-item.h" + +#define MAIN_ICON_BOX_DND_ICON_OFFSET 20 + +typedef struct _GdMainIconBoxPrivate GdMainIconBoxPrivate; + +struct _GdMainIconBoxPrivate +{ + GListModel *model; + gboolean dnd_started; + gboolean key_pressed; + gboolean key_shift_pressed; + gboolean left_button_released; + gboolean left_button_shift_released; + gboolean selection_changed; + gboolean selection_mode; + gboolean show_primary_text; + gboolean show_secondary_text; + gchar *last_selected_id; + gdouble dnd_start_x; + gdouble dnd_start_y; + gint dnd_button; +}; + +enum +{ + PROP_LAST_SELECTED_ID = 1, + PROP_MODEL, + PROP_SELECTION_MODE, + PROP_SHOW_PRIMARY_TEXT, + PROP_SHOW_SECONDARY_TEXT, + NUM_PROPERTIES +}; + +static void gd_main_box_generic_interface_init (GdMainBoxGenericInterface *iface); +G_DEFINE_TYPE_WITH_CODE (GdMainIconBox, gd_main_icon_box, GTK_TYPE_FLOW_BOX, + G_ADD_PRIVATE (GdMainIconBox) + G_IMPLEMENT_INTERFACE (GD_TYPE_MAIN_BOX_GENERIC, gd_main_box_generic_interface_init)) + +GtkWidget * +gd_main_icon_box_create_widget_func (gpointer item, gpointer user_data) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (user_data); + GdMainIconBoxPrivate *priv; + GtkWidget *child; + + g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (item), NULL); + + priv = gd_main_icon_box_get_instance_private (self); + + child = gd_main_icon_box_child_new (GD_MAIN_BOX_ITEM (item), priv->selection_mode); + g_object_bind_property (self, "show-primary-text", child, "show-primary-text", G_BINDING_SYNC_CREATE); + g_object_bind_property (self, "show-secondary-text", child, "show-secondary-text", G_BINDING_SYNC_CREATE); + gtk_widget_show_all (child); + + return child; +} + +static void +gd_main_icon_box_update_last_selected_id (GdMainIconBox *self, GdMainBoxChild *child) +{ + GdMainIconBoxPrivate *priv; + GdMainBoxItem *item; + const gchar *id = NULL; + + priv = gd_main_icon_box_get_instance_private (self); + + if (child != NULL) + { + item = gd_main_box_child_get_item (child); + id = gd_main_box_item_get_id (item); + } + + if (g_strcmp0 (priv->last_selected_id, id) != 0) + { + g_free (priv->last_selected_id); + priv->last_selected_id = g_strdup (id); + g_object_notify (G_OBJECT (self), "last-selected-id"); + } +} + +static GdMainBoxChild * +gd_main_icon_box_get_child_at_index (GdMainBoxGeneric *generic, gint index) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + GtkFlowBoxChild *child; + + child = gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self), index); + return GD_MAIN_BOX_CHILD (child); +} + +static const gchar * +gd_main_icon_box_get_last_selected_id (GdMainBoxGeneric *generic) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + return priv->last_selected_id; +} + +static GListModel * +gd_main_icon_box_get_model (GdMainBoxGeneric *generic) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + return priv->model; +} + +static GList * +gd_main_icon_box_get_selected_children (GdMainBoxGeneric *generic) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + GList *selected_children; + + selected_children = gtk_flow_box_get_selected_children (GTK_FLOW_BOX (self)); + return selected_children; +} + +static gboolean +gd_main_icon_box_get_selection_mode (GdMainIconBox *self) +{ + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + return priv->selection_mode; +} + +static gboolean +gd_main_icon_box_get_show_primary_text (GdMainIconBox *self) +{ + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + return priv->show_primary_text; +} + +static gboolean +gd_main_icon_box_get_show_secondary_text (GdMainIconBox *self) +{ + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + return priv->show_secondary_text; +} + +static void +gd_main_icon_box_select_all_generic (GdMainBoxGeneric *generic) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + g_signal_emit_by_name (self, "select-all"); +} + +static void +gd_main_icon_box_select_child (GdMainBoxGeneric *generic, GdMainBoxChild *child) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + gtk_flow_box_select_child (GTK_FLOW_BOX (self), GTK_FLOW_BOX_CHILD (child)); +} + +static void +gd_main_icon_box_set_model (GdMainIconBox *self, GListModel *model) +{ + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + if (!g_set_object (&priv->model, model)) + return; + + gtk_flow_box_bind_model (GTK_FLOW_BOX (self), + priv->model, + gd_main_icon_box_create_widget_func, + self, + NULL); + + g_object_notify (G_OBJECT (self), "model"); +} + +static void +gd_main_icon_box_set_selection_mode (GdMainIconBox *self, gboolean selection_mode) +{ + GdMainIconBoxPrivate *priv; + GList *children; + GList *l; + + priv = gd_main_icon_box_get_instance_private (self); + + if (priv->selection_mode == selection_mode) + return; + + gd_main_icon_box_update_last_selected_id (self, NULL); + + priv->selection_mode = selection_mode; + if (priv->selection_mode) + gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (self), GTK_SELECTION_MULTIPLE); + else + gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (self), GTK_SELECTION_NONE); + + children = gtk_container_get_children (GTK_CONTAINER (self)); + for (l = children; l != NULL; l = l->next) + { + GdMainBoxChild *child = GD_MAIN_BOX_CHILD (l->data); + gd_main_box_child_set_selection_mode (child, priv->selection_mode); + } + + g_object_notify (G_OBJECT (self), "last-selected-id"); + g_object_notify (G_OBJECT (self), "selection-mode"); + + g_list_free (children); +} + +static void +gd_main_icon_box_set_show_primary_text (GdMainIconBox *self, gboolean show_primary_text) +{ + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + if (priv->show_primary_text == show_primary_text) + return; + + priv->show_primary_text = show_primary_text; + g_object_notify (G_OBJECT (self), "show-primary-text"); +} + +static void +gd_main_icon_box_set_show_secondary_text (GdMainIconBox *self, gboolean show_secondary_text) +{ + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + if (priv->show_secondary_text == show_secondary_text) + return; + + priv->show_secondary_text = show_secondary_text; + g_object_notify (G_OBJECT (self), "show-secondary-text"); +} + +static void +gd_main_icon_box_unselect_all_generic (GdMainBoxGeneric *generic) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + g_signal_emit_by_name (self, "unselect-all"); +} + +static void +gd_main_icon_box_unselect_child (GdMainBoxGeneric *generic, GdMainBoxChild *child) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (generic); + gtk_flow_box_unselect_child (GTK_FLOW_BOX (self), GTK_FLOW_BOX_CHILD (child)); +} + +static void +gd_main_icon_box_activate_cursor_child (GtkFlowBox *flow_box) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box); + GdMainIconBoxPrivate *priv; + GdkEvent *event = NULL; + gboolean initiating = FALSE; + + priv = gd_main_icon_box_get_instance_private (self); + + /* Use GtkFlowBox::activate-cursor-child instead of + * GtkWidget::key-press-event to catch key presses because it is + * easier to filter out non-activation keys. + */ + + event = gtk_get_current_event (); + if (event == NULL) + goto out; + + if (event->type != GDK_KEY_PRESS) + goto out; + + if (!priv->selection_mode && (event->key.state & GDK_CONTROL_MASK) != 0) + { + g_signal_emit_by_name (self, "selection-mode-request"); + initiating = TRUE; + } + + if (priv->selection_mode) + { + if (!initiating && (event->key.state & GDK_SHIFT_MASK) != 0) + priv->key_shift_pressed = TRUE; + + priv->key_pressed = TRUE; + } + + out: + GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->activate_cursor_child (flow_box); + g_clear_pointer (&event, gdk_event_free); +} + +static gboolean +gd_main_icon_box_button_press_event (GtkWidget *widget, GdkEventButton *event) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (widget); + GdMainIconBoxPrivate *priv; + GtkFlowBoxChild *child; + gboolean res; + + priv = gd_main_icon_box_get_instance_private (self); + + if (event->type != GDK_BUTTON_PRESS) + { + res = GDK_EVENT_STOP; + goto out; + } + + if (event->button != GDK_BUTTON_PRIMARY) + goto default_behavior; + + child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self), (gint) event->x, (gint) event->y); + if (child == NULL) + goto default_behavior; + + if (priv->selection_mode && !gtk_flow_box_child_is_selected (child)) + goto default_behavior; + + priv->dnd_button = (gint) event->button; + priv->dnd_start_x = event->x; + priv->dnd_start_y = event->y; + + default_behavior: + res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->button_press_event (widget, event); + + out: + return res; +} + +static gboolean +gd_main_icon_box_button_release_event (GtkWidget *widget, GdkEventButton *event) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (widget); + GdMainIconBoxPrivate *priv; + GtkFlowBoxChild *child = NULL; + gboolean initiating = FALSE; + gboolean res; + + priv = gd_main_icon_box_get_instance_private (self); + + priv->dnd_button = -1; + priv->dnd_start_x = -1.0; + priv->dnd_start_y = -1.0; + priv->dnd_started = FALSE; + + if (event->type != GDK_BUTTON_RELEASE) + { + res = GDK_EVENT_STOP; + goto out; + } + + if (!priv->selection_mode && + ((event->button == GDK_BUTTON_PRIMARY && (event->state & GDK_CONTROL_MASK) != 0) || + event->button == GDK_BUTTON_SECONDARY)) + { + g_signal_emit_by_name (self, "selection-mode-request"); + initiating = TRUE; + } + + if (priv->selection_mode) + { + if (event->button == GDK_BUTTON_PRIMARY) + { + /* GtkFlowBox doesn't do range selection. It will simply + * select a single child for shift + left-click. We need to + * detect it so that we can handle it later. + * + * However, range selection is only possible if we were + * already in the selection mode. Therefore, skip it if we + * have just requested the selection mode. + */ + if (!initiating && (event->state & GDK_SHIFT_MASK) != 0) + priv->left_button_shift_released = TRUE; + + priv->left_button_released = TRUE; + } + else if (event->button == GDK_BUTTON_SECONDARY) + { + /* GtkFlowBox completely ignores the right mouse + * button. + */ + + child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self), (gint) event->x, (gint) event->y); + if (child != NULL) + { + gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), + GD_MAIN_BOX_CHILD (child), + (!initiating && + (event->state & GDK_SHIFT_MASK) != 0)); + } + } + } + + /* This is for right-clicks and rubberband selection. + * + * Rubberband selection is unlike other modes of selection because + * GtkFlowBox::selected-children-changed is emitted before the mouse + * button is released. + */ + if (priv->selection_changed) + { + g_signal_emit_by_name (self, "selection-changed"); + gd_main_icon_box_update_last_selected_id (self, GD_MAIN_BOX_CHILD (child)); + priv->selection_changed = FALSE; + } + + res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->button_release_event (widget, event); + + out: + return res; +} + +static void +gd_main_icon_box_child_activated (GtkFlowBox *flow_box, GtkFlowBoxChild *child) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box); + GdMainIconBoxPrivate *priv; + GdkEvent *event = NULL; + + g_return_if_fail (GD_IS_MAIN_BOX_CHILD (child)); + + priv = gd_main_icon_box_get_instance_private (self); + + /* GtkFlowBox might emit child-activated in the middle of a + * DnD. See https://bugzilla.gnome.org/show_bug.cgi?id=776306 + */ + if (priv->dnd_started) + goto out; + + if (!priv->selection_mode) + { + g_signal_emit_by_name (self, "item-activated", GD_MAIN_BOX_CHILD (child)); + goto out; + } + + event = gtk_get_current_event (); + if (event == NULL) + goto out; + + if (priv->left_button_released && !priv->selection_changed) + { + /* If a selected child is left-clicked, GtkFlowBox will activate + * it without unselecting it. + */ + gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), + GD_MAIN_BOX_CHILD (child), + FALSE); /* One cannot unselect a range. */ + priv->left_button_released = FALSE; + g_signal_emit_by_name (self, "selection-changed"); + } + else if (priv->key_pressed && !priv->selection_changed) + { + /* If a selected child is activated by a keybinding, GtkFlowBox + * will not unselect it. + */ + gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), GD_MAIN_BOX_CHILD (child), FALSE); + priv->key_pressed = FALSE; + g_signal_emit_by_name (self, "selection-changed"); + } + else if (priv->left_button_shift_released || priv->key_shift_pressed) + { + /* GtkFlowBox doesn't do range selection and simply selects a + * single child. We handle it by unselecting the child and then + * selecting the range. + */ + gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), GD_MAIN_BOX_CHILD (child), FALSE); + priv->left_button_shift_released = FALSE; + priv->key_shift_pressed = FALSE; + gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), GD_MAIN_BOX_CHILD (child), TRUE); + g_signal_emit_by_name (self, "selection-changed"); + } + else if (priv->selection_changed) + { + /* This is for non-shift left-clicks and keyboard activation of + * unselected children. + */ + g_signal_emit_by_name (self, "selection-changed"); + } + + g_signal_emit_by_name (self, "item-activated", GD_MAIN_BOX_CHILD (child)); + + if (priv->selection_changed) + { + gd_main_icon_box_update_last_selected_id (self, GD_MAIN_BOX_CHILD (child)); + priv->selection_changed = FALSE; + } + + out: + g_clear_pointer (&event, gdk_event_free); +} + +static void +gd_main_icon_box_drag_begin (GtkWidget *widget, GdkDragContext *context) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (widget); + GdMainIconBoxPrivate *priv; + GdMainBoxItem *item; + GtkFlowBoxChild *child; + cairo_surface_t *drag_icon = NULL; + cairo_surface_t *icon; + + priv = gd_main_icon_box_get_instance_private (self); + + if (priv->dnd_start_x < 0.0 || priv->dnd_start_y < 0.0) + goto out; + + child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self), + (gint) priv->dnd_start_x, + (gint) priv->dnd_start_y); + if (child == NULL) + goto out; + + item = gd_main_box_child_get_item (GD_MAIN_BOX_CHILD (child)); + icon = gd_main_box_item_get_icon (item); + if (icon == NULL) + goto out; + + if (priv->selection_mode) + { + GList *selected_children; + guint length; + + selected_children = gtk_flow_box_get_selected_children (GTK_FLOW_BOX (self)); + length = g_list_length (selected_children); + if (length > 1) + drag_icon = gd_create_surface_with_counter (GTK_WIDGET (self), icon, length); + + g_list_free (selected_children); + } + + if (drag_icon == NULL) + drag_icon = gd_copy_image_surface (icon); + + cairo_surface_set_device_offset (drag_icon, -MAIN_ICON_BOX_DND_ICON_OFFSET, -MAIN_ICON_BOX_DND_ICON_OFFSET); + gtk_drag_set_icon_surface (context, drag_icon); + + out: + g_clear_pointer (&drag_icon, cairo_surface_destroy); +} + +static void +gd_main_icon_box_add_child_uri_to_array (GdMainBoxChild *child, GPtrArray *uri_array) +{ + GdMainBoxItem *item; + const gchar *uri; + + item = gd_main_box_child_get_item (child); + uri = gd_main_box_item_get_uri (item); + g_ptr_array_add (uri_array, g_strdup (uri)); +} + +static void +gd_main_icon_box_drag_data_get (GtkWidget *widget, + GdkDragContext *context, + GtkSelectionData *data, + guint info, + guint time) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (widget); + GdMainIconBoxPrivate *priv; + GPtrArray *uri_array = NULL; + + priv = gd_main_icon_box_get_instance_private (self); + + if (info != 0) + goto out; + + if (priv->dnd_start_x < 0.0 || priv->dnd_start_y < 0.0) + goto out; + + uri_array = g_ptr_array_new_with_free_func (g_free); + + if (priv->selection_mode) + { + GList *l; + GList *selected_children; + + selected_children = gtk_flow_box_get_selected_children (GTK_FLOW_BOX (self)); + for (l = selected_children; l != NULL; l = l->next) + { + GdMainBoxChild *child = GD_MAIN_BOX_CHILD (l->data); + gd_main_icon_box_add_child_uri_to_array (child, uri_array); + } + + g_list_free (selected_children); + } + else + { + GtkFlowBoxChild *child; + + child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self), + (gint) priv->dnd_start_x, + (gint) priv->dnd_start_y); + + if (child != NULL) + gd_main_icon_box_add_child_uri_to_array (GD_MAIN_BOX_CHILD (child), uri_array); + } + + g_ptr_array_add (uri_array, NULL); + gtk_selection_data_set_uris (data, (gchar **) uri_array->pdata); + + out: + g_clear_pointer (&uri_array, g_ptr_array_unref); +} + +static gboolean +gd_main_icon_box_focus (GtkWidget *widget, GtkDirectionType direction) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (widget); + GdMainIconBoxPrivate *priv; + GdkEvent *event = NULL; + GdkEvent *fake_event = NULL; + gboolean res; + + priv = gd_main_icon_box_get_instance_private (self); + + if (!priv->selection_mode) + { + res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->focus (widget, direction); + goto out; + } + + event = gtk_get_current_event (); + if (event->type != GDK_KEY_PRESS && event->type != GDK_KEY_RELEASE) + { + res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->focus (widget, direction); + goto out; + } + + if ((event->key.state & GDK_CONTROL_MASK) != 0) + { + res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->focus (widget, direction); + goto out; + } + + fake_event = gdk_event_copy (event); + fake_event->key.state |= GDK_CONTROL_MASK; + + gtk_main_do_event (fake_event); + res = GDK_EVENT_STOP; + + out: + g_clear_pointer (&fake_event, gdk_event_free); + g_clear_pointer (&event, gdk_event_free); + return res; +} + +static gboolean +gd_main_icon_box_motion_notify_event (GtkWidget *widget, GdkEventMotion *event) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (widget); + GdMainIconBoxPrivate *priv; + GtkTargetList *targets; + gboolean res; + gint button; + + priv = gd_main_icon_box_get_instance_private (self); + + if (priv->dnd_button < 0) + goto out; + + if (!gtk_drag_check_threshold (GTK_WIDGET (self), + (gint) priv->dnd_start_x, + (gint) priv->dnd_start_y, + (gint) event->x, + (gint) event->y)) + goto out; + + button = priv->dnd_button; + priv->dnd_button = -1; + priv->dnd_started = TRUE; + + targets = gtk_drag_source_get_target_list (GTK_WIDGET (self)); + + gtk_drag_begin_with_coordinates (GTK_WIDGET (self), + targets, + GDK_ACTION_COPY, + button, + (GdkEvent *) event, + (gint) priv->dnd_start_x, + (gint) priv->dnd_start_y); + + out: + res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->motion_notify_event (widget, event); + return res; +} + +static gboolean +gd_main_icon_box_move_cursor (GtkFlowBox *flow_box, GtkMovementStep step, gint count) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box); + GdMainIconBoxPrivate *priv; + GdkEvent *event = NULL; + GdkEvent *fake_event = NULL; + gboolean res; + + priv = gd_main_icon_box_get_instance_private (self); + + if (!priv->selection_mode) + { + res = GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->move_cursor (flow_box, step, count); + goto out; + } + + event = gtk_get_current_event (); + if (event->type != GDK_KEY_PRESS && event->type != GDK_KEY_RELEASE) + { + res = GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->move_cursor (flow_box, step, count); + goto out; + } + + if ((event->key.state & GDK_CONTROL_MASK) != 0 && (event->key.state & GDK_SHIFT_MASK) == 0) + { + res = GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->move_cursor (flow_box, step, count); + goto out; + } + + fake_event = gdk_event_copy (event); + fake_event->key.state |= GDK_CONTROL_MASK; + fake_event->key.state &= ~GDK_SHIFT_MASK; + + gtk_main_do_event (fake_event); + res = GDK_EVENT_STOP; + + out: + g_clear_pointer (&fake_event, gdk_event_free); + g_clear_pointer (&event, gdk_event_free); + return res; +} + +static void +gd_main_icon_box_remove (GtkContainer *container, GtkWidget *widget) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (container); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + GTK_CONTAINER_CLASS (gd_main_icon_box_parent_class)->remove (container, widget); + + if (priv->selection_changed) + { + g_signal_emit_by_name (self, "selection-changed"); + priv->selection_changed = FALSE; + } +} + +static void +gd_main_icon_box_select_all_flow_box (GtkFlowBox *flow_box) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->select_all (flow_box); + + if (priv->selection_changed) + { + g_signal_emit_by_name (self, "selection-changed"); + priv->selection_changed = FALSE; + } +} + +static void +gd_main_icon_box_selected_children_changed (GtkFlowBox *flow_box) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->selected_children_changed (flow_box); + + priv->selection_changed = TRUE; + + /* When a range selection is attempted, we override GtkFlowBox's + * default behaviour by changing the selection ourselves. Therefore, + * there is no need to update the check buttons until the final + * selection is available. + */ + if (!priv->key_shift_pressed && !priv->left_button_shift_released) + { + GList *children; + GList *l; + + children = gtk_container_get_children (GTK_CONTAINER (self)); + for (l = children; l != NULL; l = l->next) + { + GtkFlowBoxChild *child = GTK_FLOW_BOX_CHILD (l->data); + gboolean selected; + + /* Work around the fact that GtkFlowBoxChild:selected is not + * a property. + */ + selected = gtk_flow_box_child_is_selected (child); + gd_main_box_child_set_selected (GD_MAIN_BOX_CHILD (child), selected); + } + + g_list_free (children); + } +} + +static void +gd_main_icon_box_unselect_all_flow_box (GtkFlowBox *flow_box) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->unselect_all (flow_box); + + if (priv->selection_changed) + { + g_signal_emit_by_name (self, "selection-changed"); + priv->selection_changed = FALSE; + } +} + +static void +gd_main_icon_box_dispose (GObject *obj) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (obj); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + g_clear_object (&priv->model); + + G_OBJECT_CLASS (gd_main_icon_box_parent_class)->dispose (obj); +} + +static void +gd_main_icon_box_finalize (GObject *obj) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (obj); + GdMainIconBoxPrivate *priv; + + priv = gd_main_icon_box_get_instance_private (self); + + g_free (priv->last_selected_id); + + G_OBJECT_CLASS (gd_main_icon_box_parent_class)->finalize (obj); +} + +static void +gd_main_icon_box_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (object); + + switch (property_id) + { + case PROP_LAST_SELECTED_ID: + g_value_set_string (value, gd_main_icon_box_get_last_selected_id (GD_MAIN_BOX_GENERIC (self))); + break; + case PROP_MODEL: + g_value_set_object (value, gd_main_icon_box_get_model (GD_MAIN_BOX_GENERIC (self))); + break; + case PROP_SELECTION_MODE: + g_value_set_boolean (value, gd_main_icon_box_get_selection_mode (self)); + break; + case PROP_SHOW_PRIMARY_TEXT: + g_value_set_boolean (value, gd_main_icon_box_get_show_primary_text (self)); + break; + case PROP_SHOW_SECONDARY_TEXT: + g_value_set_boolean (value, gd_main_icon_box_get_show_secondary_text (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_icon_box_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + GdMainIconBox *self = GD_MAIN_ICON_BOX (object); + + switch (property_id) + { + case PROP_MODEL: + gd_main_icon_box_set_model (self, g_value_get_object (value)); + break; + case PROP_SELECTION_MODE: + gd_main_icon_box_set_selection_mode (self, g_value_get_boolean (value)); + break; + case PROP_SHOW_PRIMARY_TEXT: + gd_main_icon_box_set_show_primary_text (self, g_value_get_boolean (value)); + break; + case PROP_SHOW_SECONDARY_TEXT: + gd_main_icon_box_set_show_secondary_text (self, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_icon_box_init (GdMainIconBox *self) +{ + GdMainIconBoxPrivate *priv; + const GtkTargetEntry targets[] = { { (gchar *) "text/uri-list", GTK_TARGET_OTHER_APP, 0 } }; + + priv = gd_main_icon_box_get_instance_private (self); + + gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE); + gtk_flow_box_set_homogeneous (GTK_FLOW_BOX (self), TRUE); + gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (self), 3); + gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (self), GTK_SELECTION_NONE); + + /* We need to ensure that rubberband selection and DnD don't step + * on each others toes. We set start_button_mask to 0 to retain + * control over when to begin a drag. + */ + gtk_drag_source_set (GTK_WIDGET (self), 0, targets, G_N_ELEMENTS (targets), GDK_ACTION_COPY); + + priv->dnd_button = -1; + priv->dnd_start_x = -1.0; + priv->dnd_start_y = -1.0; +} + +static void +gd_main_icon_box_class_init (GdMainIconBoxClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + GtkContainerClass *cclass = GTK_CONTAINER_CLASS (klass); + GtkFlowBoxClass *fbclass = GTK_FLOW_BOX_CLASS (klass); + GtkWidgetClass *wclass = GTK_WIDGET_CLASS (klass); + GtkBindingSet *binding_set; + GdkModifierType activate_modifiers[] = { 0, /* Otherwise it will go to GtkFlowBoxChild::activate. */ + GDK_SHIFT_MASK, + GDK_CONTROL_MASK, + GDK_SHIFT_MASK | GDK_CONTROL_MASK }; + guint i; + + binding_set = gtk_binding_set_by_class (klass); + + oclass->dispose = gd_main_icon_box_dispose; + oclass->finalize = gd_main_icon_box_finalize; + oclass->get_property = gd_main_icon_box_get_property; + oclass->set_property = gd_main_icon_box_set_property; + wclass->button_press_event = gd_main_icon_box_button_press_event; + wclass->button_release_event = gd_main_icon_box_button_release_event; + wclass->drag_begin = gd_main_icon_box_drag_begin; + wclass->drag_data_get = gd_main_icon_box_drag_data_get; + wclass->focus = gd_main_icon_box_focus; + wclass->motion_notify_event = gd_main_icon_box_motion_notify_event; + cclass->remove = gd_main_icon_box_remove; + fbclass->activate_cursor_child = gd_main_icon_box_activate_cursor_child; + fbclass->child_activated = gd_main_icon_box_child_activated; + fbclass->move_cursor = gd_main_icon_box_move_cursor; + fbclass->select_all = gd_main_icon_box_select_all_flow_box; + fbclass->selected_children_changed = gd_main_icon_box_selected_children_changed; + fbclass->unselect_all = gd_main_icon_box_unselect_all_flow_box; + + g_object_class_override_property (oclass, PROP_LAST_SELECTED_ID, "last-selected-id"); + g_object_class_override_property (oclass, PROP_MODEL, "model"); + g_object_class_override_property (oclass, PROP_SELECTION_MODE, "gd-selection-mode"); + g_object_class_override_property (oclass, PROP_SHOW_PRIMARY_TEXT, "show-primary-text"); + g_object_class_override_property (oclass, PROP_SHOW_SECONDARY_TEXT, "show-secondary-text"); + + for (i = 0; i < G_N_ELEMENTS (activate_modifiers); i++) + { + gtk_binding_entry_add_signal (binding_set, + GDK_KEY_space, activate_modifiers[i], + "activate-cursor-child", + 0); + gtk_binding_entry_add_signal (binding_set, + GDK_KEY_KP_Space, activate_modifiers[i], + "activate-cursor-child", + 0); + gtk_binding_entry_add_signal (binding_set, + GDK_KEY_Return, activate_modifiers[i], + "activate-cursor-child", + 0); + gtk_binding_entry_add_signal (binding_set, + GDK_KEY_ISO_Enter, activate_modifiers[i], + "activate-cursor-child", + 0); + gtk_binding_entry_add_signal (binding_set, + GDK_KEY_KP_Enter, activate_modifiers[i], + "activate-cursor-child", + 0); + } +} + +static void +gd_main_box_generic_interface_init (GdMainBoxGenericInterface *iface) +{ + iface->get_child_at_index = gd_main_icon_box_get_child_at_index; + iface->get_last_selected_id = gd_main_icon_box_get_last_selected_id; + iface->get_model = gd_main_icon_box_get_model; + iface->get_selected_children = gd_main_icon_box_get_selected_children; + iface->select_all = gd_main_icon_box_select_all_generic; + iface->select_child = gd_main_icon_box_select_child; + iface->unselect_all = gd_main_icon_box_unselect_all_generic; + iface->unselect_child = gd_main_icon_box_unselect_child; +} + +GtkWidget * +gd_main_icon_box_new (void) +{ + return g_object_new (GD_TYPE_MAIN_ICON_BOX, NULL); +} diff --git a/subprojects/libgd/libgd/gd-main-icon-box.h b/subprojects/libgd/libgd/gd-main-icon-box.h new file mode 100644 index 0000000..5dc60fe --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-box.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Debarshi Ray + * + */ + +#ifndef __GD_MAIN_ICON_BOX_H__ +#define __GD_MAIN_ICON_BOX_H__ + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_ICON_BOX gd_main_icon_box_get_type() +G_DECLARE_DERIVABLE_TYPE (GdMainIconBox, gd_main_icon_box, GD, MAIN_ICON_BOX, GtkFlowBox) + +struct _GdMainIconBoxClass +{ + GtkFlowBoxClass parent_class; + + /* signals */ + gboolean (* move_cursor) (GdMainIconBox *self, GtkMovementStep step, gint count); +}; + +GtkWidget * gd_main_icon_box_new (void); + +G_END_DECLS + +#endif /* __GD_MAIN_ICON_BOX_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-icon-view.c b/subprojects/libgd/libgd/gd-main-icon-view.c new file mode 100644 index 0000000..95bdb55 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-view.c @@ -0,0 +1,440 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-main-icon-view.h" +#include "gd-main-view-generic.h" +#include "gd-toggle-pixbuf-renderer.h" +#include "gd-two-lines-renderer.h" + +#include +#include +#include + +#define VIEW_ITEM_WIDTH 140 +#define VIEW_ITEM_WRAP_WIDTH 128 +#define VIEW_COLUMN_SPACING 20 +#define VIEW_MARGIN 16 + +typedef struct _GdMainIconViewPrivate GdMainIconViewPrivate; + +struct _GdMainIconViewPrivate { + GtkCellRenderer *pixbuf_cell; + GtkCellRenderer *text_cell; + gboolean selection_mode; +}; + +static void gd_main_view_generic_iface_init (GdMainViewGenericIface *iface); +G_DEFINE_TYPE_WITH_CODE (GdMainIconView, gd_main_icon_view, GTK_TYPE_ICON_VIEW, + G_ADD_PRIVATE (GdMainIconView) + G_IMPLEMENT_INTERFACE (GD_TYPE_MAIN_VIEW_GENERIC, + gd_main_view_generic_iface_init)) + +static GtkTreePath* +get_source_row (GdkDragContext *context) +{ + GtkTreeRowReference *ref; + + ref = g_object_get_data (G_OBJECT (context), "gtk-icon-view-source-row"); + + if (ref) + return gtk_tree_row_reference_get_path (ref); + else + return NULL; +} + +static void +set_attributes_from_model (GdMainIconView *self) +{ + GdMainIconViewPrivate *priv; + GtkTreeModel *model = gtk_icon_view_get_model (GTK_ICON_VIEW (self)); + GtkCellLayout *layout = GTK_CELL_LAYOUT (self); + GType icon_gtype; + + priv = gd_main_icon_view_get_instance_private (self); + + if (!model) + return; + + gtk_cell_layout_clear_attributes (layout, priv->pixbuf_cell); + gtk_cell_layout_clear_attributes (layout, priv->text_cell); + + gtk_cell_layout_add_attribute (layout, priv->pixbuf_cell, + "active", GD_MAIN_COLUMN_SELECTED); + gtk_cell_layout_add_attribute (layout, priv->pixbuf_cell, + "pulse", GD_MAIN_COLUMN_PULSE); + + icon_gtype = gtk_tree_model_get_column_type (model, GD_MAIN_COLUMN_ICON); + if (icon_gtype == GDK_TYPE_PIXBUF) + gtk_cell_layout_add_attribute (layout, priv->pixbuf_cell, + "pixbuf", GD_MAIN_COLUMN_ICON); + else if (icon_gtype == CAIRO_GOBJECT_TYPE_SURFACE) + gtk_cell_layout_add_attribute (layout, priv->pixbuf_cell, + "surface", GD_MAIN_COLUMN_ICON); + else + g_assert_not_reached (); + + gtk_cell_layout_add_attribute (layout, priv->text_cell, + "text", GD_MAIN_COLUMN_PRIMARY_TEXT); + gtk_cell_layout_add_attribute (layout, priv->text_cell, + "line-two", GD_MAIN_COLUMN_SECONDARY_TEXT); +} + +static void +gd_main_icon_view_drag_data_get (GtkWidget *widget, + GdkDragContext *drag_context, + GtkSelectionData *data, + guint info, + guint time) +{ + GdMainIconView *self = GD_MAIN_ICON_VIEW (widget); + GdMainIconViewPrivate *priv; + GtkTreeModel *model = gtk_icon_view_get_model (GTK_ICON_VIEW (self)); + + priv = gd_main_icon_view_get_instance_private (self); + + if (info != 0) + return; + + _gd_main_view_generic_dnd_common (model, priv->selection_mode, + get_source_row (drag_context), data); + + GTK_WIDGET_CLASS (gd_main_icon_view_parent_class)->drag_data_get (widget, drag_context, + data, info, time); +} + +static void +gd_main_icon_view_constructed (GObject *obj) +{ + GdMainIconView *self = GD_MAIN_ICON_VIEW (obj); + GdMainIconViewPrivate *priv; + GtkCellRenderer *cell; + const GtkTargetEntry targets[] = { + { (char *) "text/uri-list", GTK_TARGET_OTHER_APP, 0 } + }; + + priv = gd_main_icon_view_get_instance_private (self); + + G_OBJECT_CLASS (gd_main_icon_view_parent_class)->constructed (obj); + + gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE); + gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE); + gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (self), GTK_SELECTION_NONE); + + g_object_set (self, + "column-spacing", VIEW_COLUMN_SPACING, + "margin", VIEW_MARGIN, + NULL); + + priv->pixbuf_cell = cell = gd_toggle_pixbuf_renderer_new (); + g_object_set (cell, + "xalign", 0.5, + "yalign", 0.5, + NULL); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), cell, FALSE); + + priv->text_cell = cell = gd_two_lines_renderer_new (); + g_object_set (cell, + "xalign", 0.5, + "yalign", 0.0, + "alignment", PANGO_ALIGN_CENTER, + "wrap-mode", PANGO_WRAP_WORD_CHAR, + "wrap-width", VIEW_ITEM_WRAP_WIDTH, + "text-lines", 3, + NULL); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), cell, FALSE); + + set_attributes_from_model (self); + + gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (self), + GDK_BUTTON1_MASK, + targets, 1, + GDK_ACTION_COPY); +} + +static void +path_from_line_rects (cairo_t *cr, + GdkRectangle *lines, + int n_lines) +{ + int start_line, end_line; + GdkRectangle *r; + int i; + + /* Join rows vertically by extending to the middle */ + for (i = 0; i < n_lines - 1; i++) + { + GdkRectangle *r1 = &lines[i]; + GdkRectangle *r2 = &lines[i+1]; + int gap = r2->y - (r1->y + r1->height); + int old_y; + + r1->height += gap / 2; + old_y = r2->y; + r2->y = r1->y + r1->height; + r2->height += old_y - r2->y; + } + + cairo_new_path (cr); + start_line = 0; + + do + { + for (i = start_line; i < n_lines; i++) + { + r = &lines[i]; + if (i == start_line) + cairo_move_to (cr, r->x + r->width, r->y); + else + cairo_line_to (cr, r->x + r->width, r->y); + cairo_line_to (cr, r->x + r->width, r->y + r->height); + + if (i < n_lines - 1 && + (r->x + r->width < lines[i+1].x || + r->x > lines[i+1].x + lines[i+1].width)) + { + i++; + break; + } + } + end_line = i; + for (i = end_line - 1; i >= start_line; i--) + { + r = &lines[i]; + cairo_line_to (cr, r->x, r->y + r->height); + cairo_line_to (cr, r->x, r->y); + } + cairo_close_path (cr); + start_line = end_line; + } + while (end_line < n_lines); +} + +static gboolean +gd_main_icon_view_draw (GtkWidget *widget, + cairo_t *cr) +{ + GdMainIconView *self = GD_MAIN_ICON_VIEW (widget); + GtkAllocation allocation; + GtkStyleContext *context; + GdkRectangle line_rect; + GdkRectangle rect; + GtkTreePath *path; + GArray *lines; + GtkTreePath *rubberband_start, *rubberband_end; + + GTK_WIDGET_CLASS (gd_main_icon_view_parent_class)->draw (widget, cr); + + _gd_main_view_generic_get_rubberband_range (GD_MAIN_VIEW_GENERIC (self), + &rubberband_start, &rubberband_end); + + if (rubberband_start) + { + cairo_save (cr); + + context = gtk_widget_get_style_context (widget); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND); + + path = gtk_tree_path_copy (rubberband_start); + + line_rect.width = 0; + lines = g_array_new (FALSE, FALSE, sizeof (GdkRectangle)); + + while (gtk_tree_path_compare (path, rubberband_end) <= 0) + { + if (gtk_icon_view_get_cell_rect (GTK_ICON_VIEW (widget), + path, + NULL, &rect)) + { + if (line_rect.width == 0) + line_rect = rect; + else + { + if (rect.y == line_rect.y) + gdk_rectangle_union (&rect, &line_rect, &line_rect); + else + { + g_array_append_val (lines, line_rect); + line_rect = rect; + } + } + } + gtk_tree_path_next (path); + } + + if (line_rect.width != 0) + g_array_append_val (lines, line_rect); + + if (lines->len > 0) + { + GtkStateFlags state; + cairo_path_t *path; + GtkBorder border; + GdkRGBA border_color; + + path_from_line_rects (cr, (GdkRectangle *)lines->data, lines->len); + + /* For some reason we need to copy and reapply the path, or it gets + eaten by gtk_render_background() */ + path = cairo_copy_path (cr); + + cairo_save (cr); + cairo_clip (cr); + gtk_widget_get_allocation (widget, &allocation); + gtk_render_background (context, cr, + 0, 0, + allocation.width, allocation.height); + cairo_restore (cr); + + cairo_append_path (cr, path); + cairo_path_destroy (path); + + state = gtk_widget_get_state_flags (widget); + + G_GNUC_BEGIN_IGNORE_DEPRECATIONS; + gtk_style_context_get_border_color (context, + state, + &border_color); + G_GNUC_END_IGNORE_DEPRECATIONS; + + gtk_style_context_get_border (context, state, + &border); + + cairo_set_line_width (cr, border.left); + gdk_cairo_set_source_rgba (cr, &border_color); + cairo_stroke (cr); + } + g_array_free (lines, TRUE); + + gtk_tree_path_free (path); + + gtk_style_context_restore (context); + cairo_restore (cr); + } + + return FALSE; +} + +static void +gd_main_icon_view_class_init (GdMainIconViewClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + GtkWidgetClass *wclass = GTK_WIDGET_CLASS (klass); + GtkBindingSet *binding_set; + GdkModifierType activate_modifiers[] = { GDK_SHIFT_MASK, GDK_CONTROL_MASK, GDK_SHIFT_MASK | GDK_CONTROL_MASK }; + guint i; + + binding_set = gtk_binding_set_by_class (klass); + + oclass->constructed = gd_main_icon_view_constructed; + wclass->drag_data_get = gd_main_icon_view_drag_data_get; + wclass->draw = gd_main_icon_view_draw; + + gtk_widget_class_install_style_property (wclass, + g_param_spec_int ("check-icon-size", + "Check icon size", + "Check icon size", + -1, G_MAXINT, 40, + G_PARAM_READWRITE)); + + for (i = 0; i < G_N_ELEMENTS (activate_modifiers); i++) + { + gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, activate_modifiers[i], + "activate-cursor-item", 0); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, activate_modifiers[i], + "activate-cursor-item", 0); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, activate_modifiers[i], + "activate-cursor-item", 0); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, activate_modifiers[i], + "activate-cursor-item", 0); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, activate_modifiers[i], + "activate-cursor-item", 0); + } +} + +static void +gd_main_icon_view_init (GdMainIconView *self) +{ + g_signal_connect (self, "notify::model", + G_CALLBACK (set_attributes_from_model), NULL); +} + +static GtkTreePath * +gd_main_icon_view_get_path_at_pos (GdMainViewGeneric *mv, + gint x, + gint y) +{ + return gtk_icon_view_get_path_at_pos (GTK_ICON_VIEW (mv), x, y); +} + +static void +gd_main_icon_view_set_selection_mode (GdMainViewGeneric *mv, + gboolean selection_mode) +{ + GdMainIconView *self = GD_MAIN_ICON_VIEW (mv); + GdMainIconViewPrivate *priv; + + priv = gd_main_icon_view_get_instance_private (self); + + priv->selection_mode = selection_mode; + + g_object_set (priv->pixbuf_cell, + "toggle-visible", selection_mode, + NULL); + gtk_widget_queue_draw (GTK_WIDGET (self)); +} + +static void +gd_main_icon_view_scroll_to_path (GdMainViewGeneric *mv, + GtkTreePath *path) +{ + gtk_icon_view_scroll_to_path (GTK_ICON_VIEW (mv), path, TRUE, 0.5, 0.5); +} + +static void +gd_main_icon_view_set_model (GdMainViewGeneric *mv, + GtkTreeModel *model) +{ + gtk_icon_view_set_model (GTK_ICON_VIEW (mv), model); +} + +static GtkTreeModel * +gd_main_icon_view_get_model (GdMainViewGeneric *mv) +{ + return gtk_icon_view_get_model (GTK_ICON_VIEW (mv)); +} + +static void +gd_main_view_generic_iface_init (GdMainViewGenericIface *iface) +{ + iface->set_model = gd_main_icon_view_set_model; + iface->get_model = gd_main_icon_view_get_model; + iface->get_path_at_pos = gd_main_icon_view_get_path_at_pos; + iface->scroll_to_path = gd_main_icon_view_scroll_to_path; + iface->set_selection_mode = gd_main_icon_view_set_selection_mode; +} + +GtkWidget * +gd_main_icon_view_new (void) +{ + return g_object_new (GD_TYPE_MAIN_ICON_VIEW, NULL); +} diff --git a/subprojects/libgd/libgd/gd-main-icon-view.h b/subprojects/libgd/libgd/gd-main-icon-view.h new file mode 100644 index 0000000..c93e279 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-icon-view.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef __GD_MAIN_ICON_VIEW_H__ +#define __GD_MAIN_ICON_VIEW_H__ + +#include +#include + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_ICON_VIEW gd_main_icon_view_get_type() +G_DECLARE_DERIVABLE_TYPE (GdMainIconView, gd_main_icon_view, GD, MAIN_ICON_VIEW, GtkIconView) + +struct _GdMainIconViewClass +{ + GtkIconViewClass parent_class; +}; + +GtkWidget * gd_main_icon_view_new (void); + +G_END_DECLS + +#endif /* __GD_MAIN_ICON_VIEW_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-list-view.c b/subprojects/libgd/libgd/gd-main-list-view.c new file mode 100644 index 0000000..ae985a1 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-list-view.c @@ -0,0 +1,345 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-main-list-view.h" +#include "gd-main-view-generic.h" +#include "gd-two-lines-renderer.h" + +#include +#include + +struct _GdMainListViewPrivate { + GtkTreeViewColumn *tree_col; + GtkCellRenderer *pixbuf_cell; + GtkCellRenderer *selection_cell; + GtkCellRenderer *text_cell; + + gboolean selection_mode; +}; + +static void gd_main_view_generic_iface_init (GdMainViewGenericIface *iface); +G_DEFINE_TYPE_WITH_CODE (GdMainListView, gd_main_list_view, GTK_TYPE_TREE_VIEW, + G_ADD_PRIVATE (GdMainListView) + G_IMPLEMENT_INTERFACE (GD_TYPE_MAIN_VIEW_GENERIC, + gd_main_view_generic_iface_init)) + +static gboolean gd_main_list_view_draw (GtkWidget *widget, + cairo_t *cr); + +static GtkTreePath* +get_source_row (GdkDragContext *context) +{ + GtkTreeRowReference *ref = + g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row"); + + if (ref) + return gtk_tree_row_reference_get_path (ref); + else + return NULL; +} + +static void +set_attributes_from_model (GdMainListView *self) +{ + GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (self)); + GType icon_gtype; + + if (!model) + return; + + gtk_tree_view_column_clear_attributes (self->priv->tree_col, self->priv->pixbuf_cell); + gtk_tree_view_column_clear_attributes (self->priv->tree_col, self->priv->selection_cell); + gtk_tree_view_column_clear_attributes (self->priv->tree_col, self->priv->text_cell); + + + gtk_tree_view_column_add_attribute (self->priv->tree_col, self->priv->selection_cell, + "active", GD_MAIN_COLUMN_SELECTED); + + icon_gtype = gtk_tree_model_get_column_type (model, GD_MAIN_COLUMN_ICON); + if (icon_gtype == GDK_TYPE_PIXBUF) + gtk_tree_view_column_add_attribute (self->priv->tree_col, self->priv->pixbuf_cell, + "pixbuf", GD_MAIN_COLUMN_ICON); + else if (icon_gtype == CAIRO_GOBJECT_TYPE_SURFACE) + gtk_tree_view_column_add_attribute (self->priv->tree_col, self->priv->pixbuf_cell, + "surface", GD_MAIN_COLUMN_ICON); + else + g_assert_not_reached (); + + gtk_tree_view_column_add_attribute (self->priv->tree_col, self->priv->text_cell, + "text", GD_MAIN_COLUMN_PRIMARY_TEXT); + gtk_tree_view_column_add_attribute (self->priv->tree_col, self->priv->text_cell, + "line-two", GD_MAIN_COLUMN_SECONDARY_TEXT); +} + +static void +gd_main_list_view_drag_data_get (GtkWidget *widget, + GdkDragContext *drag_context, + GtkSelectionData *data, + guint info, + guint time) +{ + GdMainListView *self = GD_MAIN_LIST_VIEW (widget); + GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (self)); + + if (info != 0) + return; + + _gd_main_view_generic_dnd_common (model, + self->priv->selection_mode, + get_source_row (drag_context), data); + + GTK_WIDGET_CLASS (gd_main_list_view_parent_class)->drag_data_get (widget, drag_context, + data, info, time); +} + +static void +gd_main_list_view_constructed (GObject *obj) +{ + GdMainListView *self = GD_MAIN_LIST_VIEW (obj); + GtkCellRenderer *cell; + GtkTreeSelection *selection; + const GtkTargetEntry targets[] = { + { "text/uri-list", GTK_TARGET_OTHER_APP, 0 } + }; + + G_OBJECT_CLASS (gd_main_list_view_parent_class)->constructed (obj); + + gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE); + gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE); + + g_object_set (self, + "headers-visible", FALSE, + "enable-search", FALSE, + NULL); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self)); + gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE); + + self->priv->tree_col = gtk_tree_view_column_new (); + gtk_tree_view_append_column (GTK_TREE_VIEW (self), self->priv->tree_col); + + self->priv->selection_cell = cell = gtk_cell_renderer_toggle_new (); + g_object_set (cell, + "visible", FALSE, + "xpad", 12, + "xalign", 1.0, + NULL); + gtk_tree_view_column_pack_start (self->priv->tree_col, cell, FALSE); + + self->priv->pixbuf_cell = cell = gtk_cell_renderer_pixbuf_new (); + g_object_set (cell, + "xalign", 0.5, + "yalign", 0.5, + "xpad", 12, + "ypad", 2, + NULL); + gtk_tree_view_column_pack_start (self->priv->tree_col, cell, FALSE); + + self->priv->text_cell = cell = gd_two_lines_renderer_new (); + g_object_set (cell, + "xalign", 0.0, + "wrap-mode", PANGO_WRAP_WORD_CHAR, + "xpad", 12, + "text-lines", 2, + NULL); + gtk_tree_view_column_pack_start (self->priv->tree_col, cell, TRUE); + + set_attributes_from_model (self); + + gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (self), + GDK_BUTTON1_MASK, + targets, 1, + GDK_ACTION_COPY); +} + +static void +gd_main_list_view_class_init (GdMainListViewClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + GtkWidgetClass *wclass = GTK_WIDGET_CLASS (klass); + GtkBindingSet *binding_set; + GdkModifierType activate_modifiers[] = { GDK_SHIFT_MASK, GDK_CONTROL_MASK, GDK_SHIFT_MASK | GDK_CONTROL_MASK }; + guint i; + + binding_set = gtk_binding_set_by_class (klass); + + oclass->constructed = gd_main_list_view_constructed; + wclass->drag_data_get = gd_main_list_view_drag_data_get; + wclass->draw = gd_main_list_view_draw; + + for (i = 0; i < G_N_ELEMENTS (activate_modifiers); i++) + { + gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, activate_modifiers[i], + "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, activate_modifiers[i], + "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, activate_modifiers[i], + "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, activate_modifiers[i], + "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, activate_modifiers[i], + "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE); + } + +} + +static void +gd_main_list_view_init (GdMainListView *self) +{ + self->priv = gd_main_list_view_get_instance_private (self); + + g_signal_connect (self, "notify::model", + G_CALLBACK (set_attributes_from_model), NULL); +} + +static GtkTreePath * +gd_main_list_view_get_path_at_pos (GdMainViewGeneric *mv, + gint x, + gint y) +{ + GtkTreePath *path = NULL; + + gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (mv), x, y, &path, + NULL, NULL, NULL); + + return path; +} + +static void +gd_main_list_view_set_selection_mode (GdMainViewGeneric *mv, + gboolean selection_mode) +{ + GdMainListView *self = GD_MAIN_LIST_VIEW (mv); + + self->priv->selection_mode = selection_mode; + + g_object_set (self->priv->selection_cell, + "visible", selection_mode, + NULL); + gtk_tree_view_column_queue_resize (self->priv->tree_col); +} + +static gboolean +gd_main_list_view_draw (GtkWidget *widget, + cairo_t *cr) +{ + GdMainListView *self = GD_MAIN_LIST_VIEW (widget); + GtkStyleContext *context; + GdkRectangle lines_rect; + GdkRectangle rect; + GtkTreePath *path; + GtkTreePath *rubberband_start, *rubberband_end; + + GTK_WIDGET_CLASS (gd_main_list_view_parent_class)->draw (widget, cr); + + _gd_main_view_generic_get_rubberband_range (GD_MAIN_VIEW_GENERIC (self), + &rubberband_start, &rubberband_end); + + if (rubberband_start) + { + context = gtk_widget_get_style_context (widget); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND); + + path = gtk_tree_path_copy (rubberband_start); + + lines_rect.width = 0; + + while (gtk_tree_path_compare (path, rubberband_end) <= 0) + { + gtk_tree_view_get_cell_area (GTK_TREE_VIEW (self), + path, self->priv->tree_col, &rect); + if (lines_rect.width == 0) + lines_rect = rect; + else + gdk_rectangle_union (&rect, &lines_rect, &lines_rect); + + gtk_tree_path_next (path); + } + gtk_tree_path_free (path); + + gtk_render_background (context, cr, + lines_rect.x, lines_rect.y, + lines_rect.width, lines_rect.height); + gtk_render_frame (context, cr, + lines_rect.x, lines_rect.y, + lines_rect.width, lines_rect.height); + + + gtk_style_context_restore (context); + } + + return FALSE; +} + +static void +gd_main_list_view_scroll_to_path (GdMainViewGeneric *mv, + GtkTreePath *path) +{ + gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (mv), path, NULL, TRUE, 0.5, 0.5); +} + +static void +gd_main_list_view_set_model (GdMainViewGeneric *mv, + GtkTreeModel *model) +{ + gtk_tree_view_set_model (GTK_TREE_VIEW (mv), model); +} + +static GtkTreeModel * +gd_main_list_view_get_model (GdMainViewGeneric *mv) +{ + return gtk_tree_view_get_model (GTK_TREE_VIEW (mv)); +} + +static void +gd_main_view_generic_iface_init (GdMainViewGenericIface *iface) +{ + iface->set_model = gd_main_list_view_set_model; + iface->get_model = gd_main_list_view_get_model; + iface->get_path_at_pos = gd_main_list_view_get_path_at_pos; + iface->scroll_to_path = gd_main_list_view_scroll_to_path; + iface->set_selection_mode = gd_main_list_view_set_selection_mode; +} + +void +gd_main_list_view_add_renderer (GdMainListView *self, + GtkCellRenderer *renderer, + GtkTreeCellDataFunc func, + gpointer user_data, + GDestroyNotify destroy) +{ + gtk_tree_view_column_pack_start (self->priv->tree_col, renderer, FALSE); + gtk_tree_view_column_set_cell_data_func (self->priv->tree_col, renderer, + func, user_data, destroy); +} + +GtkWidget * +gd_main_list_view_new (void) +{ + return g_object_new (GD_TYPE_MAIN_LIST_VIEW, NULL); +} diff --git a/subprojects/libgd/libgd/gd-main-list-view.h b/subprojects/libgd/libgd/gd-main-list-view.h new file mode 100644 index 0000000..317e9c4 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-list-view.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef __GD_MAIN_LIST_VIEW_H__ +#define __GD_MAIN_LIST_VIEW_H__ + +#include +#include + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_LIST_VIEW gd_main_list_view_get_type() + +#define GD_MAIN_LIST_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ + GD_TYPE_MAIN_LIST_VIEW, GdMainListView)) + +#define GD_MAIN_LIST_VIEW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), \ + GD_TYPE_MAIN_LIST_VIEW, GdMainListViewClass)) + +#define GD_IS_MAIN_LIST_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ + GD_TYPE_MAIN_LIST_VIEW)) + +#define GD_IS_MAIN_LIST_VIEW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), \ + GD_TYPE_MAIN_LIST_VIEW)) + +#define GD_MAIN_LIST_VIEW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), \ + GD_TYPE_MAIN_LIST_VIEW, GdMainListViewClass)) + +typedef struct _GdMainListView GdMainListView; +typedef struct _GdMainListViewClass GdMainListViewClass; +typedef struct _GdMainListViewPrivate GdMainListViewPrivate; + +struct _GdMainListView +{ + GtkTreeView parent; + + GdMainListViewPrivate *priv; +}; + +struct _GdMainListViewClass +{ + GtkTreeViewClass parent_class; +}; + +GType gd_main_list_view_get_type (void) G_GNUC_CONST; + +GtkWidget * gd_main_list_view_new (void); + +void gd_main_list_view_add_renderer (GdMainListView *self, + GtkCellRenderer *renderer, + GtkTreeCellDataFunc func, + gpointer user_data, + GDestroyNotify destroy); + +G_END_DECLS + +#endif /* __GD_MAIN_LIST_VIEW_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-view-generic.c b/subprojects/libgd/libgd/gd-main-view-generic.c new file mode 100644 index 0000000..51347e0 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-view-generic.c @@ -0,0 +1,330 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-main-view-generic.h" + +enum { + VIEW_SELECTION_CHANGED, + NUM_SIGNALS +}; + +static guint signals[NUM_SIGNALS] = { 0, }; + +typedef GdMainViewGenericIface GdMainViewGenericInterface; +G_DEFINE_INTERFACE (GdMainViewGeneric, gd_main_view_generic, GTK_TYPE_WIDGET) + +static void +gd_main_view_generic_default_init (GdMainViewGenericInterface *iface) +{ + signals[VIEW_SELECTION_CHANGED] = + g_signal_new ("view-selection-changed", + GD_TYPE_MAIN_VIEW_GENERIC, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); +} + +/** + * gd_main_view_generic_set_model: + * @self: + * @model: (allow-none): + * + */ +void +gd_main_view_generic_set_model (GdMainViewGeneric *self, + GtkTreeModel *model) +{ + GdMainViewGenericInterface *iface; + + iface = GD_MAIN_VIEW_GENERIC_GET_IFACE (self); + + (* iface->set_model) (self, model); +} + +GtkTreePath * +gd_main_view_generic_get_path_at_pos (GdMainViewGeneric *self, + gint x, + gint y) +{ + GdMainViewGenericInterface *iface; + + iface = GD_MAIN_VIEW_GENERIC_GET_IFACE (self); + + return (* iface->get_path_at_pos) (self, x, y); +} + +void +gd_main_view_generic_set_selection_mode (GdMainViewGeneric *self, + gboolean selection_mode) +{ + GdMainViewGenericInterface *iface; + + iface = GD_MAIN_VIEW_GENERIC_GET_IFACE (self); + + (* iface->set_selection_mode) (self, selection_mode); +} + + +typedef struct { + GtkTreePath *rubberband_start; + GtkTreePath *rubberband_end; +} RubberbandInfo; + +static void +rubber_band_info_destroy (RubberbandInfo *info) +{ + g_clear_pointer (&info->rubberband_start, + gtk_tree_path_free); + g_clear_pointer (&info->rubberband_end, + gtk_tree_path_free); + g_slice_free (RubberbandInfo, info); +} + +static RubberbandInfo* +get_rubber_band_info (GdMainViewGeneric *self) +{ + RubberbandInfo *info; + + info = g_object_get_data (G_OBJECT (self), "gd-main-view-generic-rubber-band"); + if (info == NULL) + { + info = g_slice_new0 (RubberbandInfo); + g_object_set_data_full (G_OBJECT (self), "gd-main-view-generic-rubber-band", + info, (GDestroyNotify)rubber_band_info_destroy); + } + + return info; +} + +void +gd_main_view_generic_set_rubberband_range (GdMainViewGeneric *self, + GtkTreePath *start, + GtkTreePath *end) +{ + RubberbandInfo *info; + + info = get_rubber_band_info (self); + + if (start == NULL || end == NULL) + { + g_clear_pointer (&info->rubberband_start, + gtk_tree_path_free); + g_clear_pointer (&info->rubberband_end, + gtk_tree_path_free); + } + else + { + if (gtk_tree_path_compare (start, end) < 0) + { + info->rubberband_start = gtk_tree_path_copy (start); + info->rubberband_end = gtk_tree_path_copy (end); + } + else + { + info->rubberband_start = gtk_tree_path_copy (end); + info->rubberband_end = gtk_tree_path_copy (start); + } + } + + gtk_widget_queue_draw (GTK_WIDGET (self)); +} + +void +_gd_main_view_generic_get_rubberband_range (GdMainViewGeneric *self, + GtkTreePath **start, + GtkTreePath **end) +{ + RubberbandInfo *info; + + info = get_rubber_band_info (self); + + *start = info->rubberband_start; + *end = info->rubberband_end; +} + +void +gd_main_view_generic_scroll_to_path (GdMainViewGeneric *self, + GtkTreePath *path) +{ + GdMainViewGenericInterface *iface; + + iface = GD_MAIN_VIEW_GENERIC_GET_IFACE (self); + + (* iface->scroll_to_path) (self, path); +} + +/** + * gd_main_view_generic_get_model: + * + * Returns: (transfer none): The associated model + */ +GtkTreeModel * +gd_main_view_generic_get_model (GdMainViewGeneric *self) +{ + GdMainViewGenericInterface *iface; + + iface = GD_MAIN_VIEW_GENERIC_GET_IFACE (self); + + return (* iface->get_model) (self); +} + +static gboolean +build_selection_uris_foreach (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer user_data) +{ + GPtrArray *ptr_array = user_data; + gchar *uri; + gboolean is_selected; + + gtk_tree_model_get (model, iter, + GD_MAIN_COLUMN_URI, &uri, + GD_MAIN_COLUMN_SELECTED, &is_selected, + -1); + + if (is_selected) + g_ptr_array_add (ptr_array, uri); + else + g_free (uri); + + return FALSE; +} + +static gchar ** +model_get_selection_uris (GtkTreeModel *model) +{ + GPtrArray *ptr_array = g_ptr_array_new (); + + gtk_tree_model_foreach (model, + build_selection_uris_foreach, + ptr_array); + + g_ptr_array_add (ptr_array, NULL); + return (gchar **) g_ptr_array_free (ptr_array, FALSE); +} + +static gboolean +set_selection_foreach (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer user_data) +{ + gboolean selection = GPOINTER_TO_INT (user_data); + GtkTreeModel *actual_model; + GtkTreeIter real_iter; + + if (GTK_IS_TREE_MODEL_FILTER (model)) + { + actual_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model)); + gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), + &real_iter, iter); + } + else if (GTK_IS_TREE_MODEL_SORT (model)) + { + actual_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (model)); + gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model), + &real_iter, iter); + } + else + { + actual_model = model; + real_iter = *iter; + } + + if (GTK_IS_LIST_STORE (actual_model)) + { + gtk_list_store_set (GTK_LIST_STORE (actual_model), &real_iter, + GD_MAIN_COLUMN_SELECTED, selection, + -1); + } + else + { + gtk_tree_store_set (GTK_TREE_STORE (actual_model), &real_iter, + GD_MAIN_COLUMN_SELECTED, selection, + -1); + } + + return FALSE; +} + +static void +set_all_selection (GdMainViewGeneric *self, + GtkTreeModel *model, + gboolean selection) +{ + gtk_tree_model_foreach (model, + set_selection_foreach, + GINT_TO_POINTER (selection)); + g_signal_emit (self, signals[VIEW_SELECTION_CHANGED], 0); +} + +void +gd_main_view_generic_select_all (GdMainViewGeneric *self) +{ + GtkTreeModel *model = gd_main_view_generic_get_model (self); + + set_all_selection (self, model, TRUE); +} + +void +gd_main_view_generic_unselect_all (GdMainViewGeneric *self) +{ + GtkTreeModel *model = gd_main_view_generic_get_model (self); + + set_all_selection (self, model, FALSE); +} + +void +_gd_main_view_generic_dnd_common (GtkTreeModel *model, + gboolean selection_mode, + GtkTreePath *path, + GtkSelectionData *data) +{ + gchar **uris; + + if (selection_mode) + { + uris = model_get_selection_uris (model); + } + else + { + GtkTreeIter iter; + gboolean res; + gchar *uri = NULL; + + if (path != NULL) + { + res = gtk_tree_model_get_iter (model, &iter, path); + if (res) + gtk_tree_model_get (model, &iter, + GD_MAIN_COLUMN_URI, &uri, + -1); + } + + uris = g_new0 (gchar *, 2); + uris[0] = uri; + uris[1] = NULL; + } + + gtk_selection_data_set_uris (data, uris); + g_strfreev (uris); +} diff --git a/subprojects/libgd/libgd/gd-main-view-generic.h b/subprojects/libgd/libgd/gd-main-view-generic.h new file mode 100644 index 0000000..dd53e0e --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-view-generic.h @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef __GD_MAIN_VIEW_GENERIC_H__ +#define __GD_MAIN_VIEW_GENERIC_H__ + +#include + +#include + +G_BEGIN_DECLS + +typedef enum { + GD_MAIN_COLUMN_ID, + GD_MAIN_COLUMN_URI, + GD_MAIN_COLUMN_PRIMARY_TEXT, + GD_MAIN_COLUMN_SECONDARY_TEXT, + GD_MAIN_COLUMN_ICON, + GD_MAIN_COLUMN_MTIME, + GD_MAIN_COLUMN_SELECTED, + GD_MAIN_COLUMN_PULSE, + + GD_MAIN_COLUMN_LAST +} GdMainColumns; + +#define GD_TYPE_MAIN_VIEW_GENERIC gd_main_view_generic_get_type() + +#define GD_MAIN_VIEW_GENERIC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ + GD_TYPE_MAIN_VIEW_GENERIC, GdMainViewGeneric)) + +#define GD_MAIN_VIEW_GENERIC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), \ + GD_TYPE_MAIN_VIEW_GENERIC, GdMainViewGenericIface)) + +#define GD_IS_MAIN_VIEW_GENERIC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ + GD_TYPE_MAIN_VIEW_GENERIC)) + +#define GD_IS_MAIN_VIEW_GENERIC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), \ + GD_TYPE_MAIN_VIEW_GENERIC)) + +#define GD_MAIN_VIEW_GENERIC_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), \ + GD_TYPE_MAIN_VIEW_GENERIC, GdMainViewGenericIface)) + +typedef struct _GdMainViewGeneric GdMainViewGeneric; +typedef struct _GdMainViewGenericIface GdMainViewGenericIface; + +struct _GdMainViewGenericIface +{ + GTypeInterface base_iface; + + /* vtable */ + void (* set_model) (GdMainViewGeneric *self, + GtkTreeModel *model); + GtkTreeModel * (* get_model) (GdMainViewGeneric *self); + + GtkTreePath * (* get_path_at_pos) (GdMainViewGeneric *self, + gint x, + gint y); + void (* scroll_to_path) (GdMainViewGeneric *self, + GtkTreePath *path); + void (* set_selection_mode) (GdMainViewGeneric *self, + gboolean selection_mode); +}; + +GType gd_main_view_generic_get_type (void) G_GNUC_CONST; + +void gd_main_view_generic_set_model (GdMainViewGeneric *self, + GtkTreeModel *model); +GtkTreeModel * gd_main_view_generic_get_model (GdMainViewGeneric *self); + +void gd_main_view_generic_scroll_to_path (GdMainViewGeneric *self, + GtkTreePath *path); +void gd_main_view_generic_set_selection_mode (GdMainViewGeneric *self, + gboolean selection_mode); +GtkTreePath * gd_main_view_generic_get_path_at_pos (GdMainViewGeneric *self, + gint x, + gint y); +void gd_main_view_generic_select_all (GdMainViewGeneric *self); +void gd_main_view_generic_unselect_all (GdMainViewGeneric *self); +void gd_main_view_generic_set_rubberband_range (GdMainViewGeneric *self, + GtkTreePath *start, + GtkTreePath *end); + +/* private */ +void _gd_main_view_generic_dnd_common (GtkTreeModel *model, + gboolean selection_mode, + GtkTreePath *path, + GtkSelectionData *data); +void _gd_main_view_generic_get_rubberband_range (GdMainViewGeneric *self, + GtkTreePath **start, + GtkTreePath **end); + +G_END_DECLS + +#endif /* __GD_MAIN_VIEW_GENERIC_H__ */ diff --git a/subprojects/libgd/libgd/gd-main-view.c b/subprojects/libgd/libgd/gd-main-view.c new file mode 100644 index 0000000..008162b --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-view.c @@ -0,0 +1,1160 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-main-view.h" + +#include "gd-icon-utils.h" +#include "gd-main-view-generic.h" +#include "gd-main-icon-view.h" +#include "gd-main-list-view.h" + +#include +#include + +#define MAIN_VIEW_TYPE_INITIAL -1 +#define MAIN_VIEW_DND_ICON_OFFSET 20 +#define MAIN_VIEW_RUBBERBAND_SELECT_TRIGGER_LENGTH 32 + +typedef struct _GdMainViewPrivate GdMainViewPrivate; + +struct _GdMainViewPrivate { + GdMainViewType current_type; + gboolean selection_mode; + + GtkWidget *current_view; + GtkTreeModel *model; + + gboolean track_motion; + gboolean rubberband_select; + GtkTreePath *rubberband_select_first_path; + GtkTreePath *rubberband_select_last_path; + int button_down_x; + int button_down_y; + + gchar *button_press_item_path; + + gchar *last_selected_id; +}; + +enum { + PROP_VIEW_TYPE = 1, + PROP_SELECTION_MODE, + PROP_MODEL, + NUM_PROPERTIES +}; + +enum { + ITEM_ACTIVATED = 1, + SELECTION_MODE_REQUEST, + VIEW_SELECTION_CHANGED, + NUM_SIGNALS +}; + +static GParamSpec *properties[NUM_PROPERTIES] = { NULL, }; +static guint signals[NUM_SIGNALS] = { 0, }; + +G_DEFINE_TYPE_WITH_PRIVATE (GdMainView, gd_main_view, GTK_TYPE_SCROLLED_WINDOW) + +static void +gd_main_view_dispose (GObject *obj) +{ + GdMainView *self = GD_MAIN_VIEW (obj); + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + + g_clear_object (&priv->model); + + G_OBJECT_CLASS (gd_main_view_parent_class)->dispose (obj); +} + +static void +gd_main_view_finalize (GObject *obj) +{ + GdMainView *self = GD_MAIN_VIEW (obj); + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + + g_free (priv->button_press_item_path); + g_free (priv->last_selected_id); + + if (priv->rubberband_select_first_path) + gtk_tree_path_free (priv->rubberband_select_first_path); + + if (priv->rubberband_select_last_path) + gtk_tree_path_free (priv->rubberband_select_last_path); + + G_OBJECT_CLASS (gd_main_view_parent_class)->finalize (obj); +} + +static void +gd_main_view_init (GdMainView *self) +{ + GdMainViewPrivate *priv; + GtkStyleContext *context; + + priv = gd_main_view_get_instance_private (self); + + /* so that we get constructed with the right view even at startup */ + priv->current_type = MAIN_VIEW_TYPE_INITIAL; + + gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE); + gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (self), GTK_SHADOW_IN); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (self), + GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + + context = gtk_widget_get_style_context (GTK_WIDGET (self)); + gtk_style_context_add_class (context, "documents-scrolledwin"); +} + +static void +gd_main_view_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GdMainView *self = GD_MAIN_VIEW (object); + + switch (property_id) + { + case PROP_VIEW_TYPE: + g_value_set_int (value, gd_main_view_get_view_type (self)); + break; + case PROP_SELECTION_MODE: + g_value_set_boolean (value, gd_main_view_get_selection_mode (self)); + break; + case PROP_MODEL: + g_value_set_object (value, gd_main_view_get_model (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_view_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GdMainView *self = GD_MAIN_VIEW (object); + + switch (property_id) + { + case PROP_VIEW_TYPE: + gd_main_view_set_view_type (self, g_value_get_int (value)); + break; + case PROP_SELECTION_MODE: + gd_main_view_set_selection_mode (self, g_value_get_boolean (value)); + break; + case PROP_MODEL: + gd_main_view_set_model (self, g_value_get_object (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_main_view_class_init (GdMainViewClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->get_property = gd_main_view_get_property; + oclass->set_property = gd_main_view_set_property; + oclass->dispose = gd_main_view_dispose; + oclass->finalize = gd_main_view_finalize; + + properties[PROP_VIEW_TYPE] = + g_param_spec_int ("view-type", + "View type", + "View type", + GD_MAIN_VIEW_ICON, + GD_MAIN_VIEW_LIST, + GD_MAIN_VIEW_ICON, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + properties[PROP_SELECTION_MODE] = + g_param_spec_boolean ("selection-mode", + "Selection mode", + "Whether the view is in selection mode", + FALSE, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + properties[PROP_MODEL] = + g_param_spec_object ("model", + "Model", + "The GtkTreeModel", + GTK_TYPE_TREE_MODEL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT | + G_PARAM_STATIC_STRINGS); + + signals[ITEM_ACTIVATED] = + g_signal_new ("item-activated", + GD_TYPE_MAIN_VIEW, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 2, + G_TYPE_STRING, + GTK_TYPE_TREE_PATH); + + signals[SELECTION_MODE_REQUEST] = + g_signal_new ("selection-mode-request", + GD_TYPE_MAIN_VIEW, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + + signals[VIEW_SELECTION_CHANGED] = + g_signal_new ("view-selection-changed", + GD_TYPE_MAIN_VIEW, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + + g_object_class_install_properties (oclass, NUM_PROPERTIES, properties); +} + +static GdMainViewGeneric * +get_generic (GdMainView *self) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + + if (priv->current_view != NULL) + return GD_MAIN_VIEW_GENERIC (priv->current_view); + + return NULL; +} + +static void +do_select_row (GdMainView *self, + GtkTreeIter *iter, + gboolean value) +{ + GdMainViewPrivate *priv; + GtkTreeModel *model; + GtkTreeIter my_iter; + GtkTreePath *path; + + priv = gd_main_view_get_instance_private (self); + + model = priv->model; + my_iter = *iter; + + while (GTK_IS_TREE_MODEL_FILTER (model) || + GTK_IS_TREE_MODEL_SORT (model)) + { + GtkTreeIter child_iter; + + if (GTK_IS_TREE_MODEL_FILTER (model)) + { + GtkTreeModelFilter *filter; + + filter = GTK_TREE_MODEL_FILTER (model); + gtk_tree_model_filter_convert_iter_to_child_iter (filter, &child_iter, &my_iter); + model = gtk_tree_model_filter_get_model (filter); + } + else + { + GtkTreeModelSort *sort; + + sort = GTK_TREE_MODEL_SORT (model); + gtk_tree_model_sort_convert_iter_to_child_iter (sort, &child_iter, &my_iter); + model = gtk_tree_model_sort_get_model (sort); + } + + my_iter = child_iter; + } + + if (GTK_IS_LIST_STORE (model)) + { + gtk_list_store_set (GTK_LIST_STORE (model), &my_iter, + GD_MAIN_COLUMN_SELECTED, value, + -1); + } + else + { + gtk_tree_store_set (GTK_TREE_STORE (model), &my_iter, + GD_MAIN_COLUMN_SELECTED, value, + -1); + } + + /* And tell the view model that something changed */ + path = gtk_tree_model_get_path (priv->model, iter); + if (path) + { + gtk_tree_model_row_changed (priv->model, path, iter); + gtk_tree_path_free (path); + } +} + +static void +selection_mode_do_select_range (GdMainView *self, + GtkTreeIter *first_element, + GtkTreeIter *last_element) +{ + GdMainViewPrivate *priv; + GtkTreeIter iter; + GtkTreePath *path, *last_path; + gboolean equal; + + priv = gd_main_view_get_instance_private (self); + + path = gtk_tree_model_get_path (priv->model, first_element); + last_path = gtk_tree_model_get_path (priv->model, last_element); + if (gtk_tree_path_compare (path, last_path) > 0) + { + gtk_tree_path_free (last_path); + last_path = path; + iter = *last_element; + } + else + { + gtk_tree_path_free (path); + iter = *first_element; + } + + do + { + do_select_row (self, &iter, TRUE); + + path = gtk_tree_model_get_path (priv->model, &iter); + equal = (gtk_tree_path_compare (path, last_path) == 0); + gtk_tree_path_free (path); + + if (equal) + break; + } + while (gtk_tree_model_iter_next (priv->model, &iter)); + + gtk_tree_path_free (last_path); +} + +static void +selection_mode_select_range (GdMainView *self, + GtkTreeIter *iter) +{ + GdMainViewPrivate *priv; + GtkTreeIter other; + gboolean found = FALSE; + gboolean selected; + char *id; + + priv = gd_main_view_get_instance_private (self); + + if (priv->last_selected_id != NULL && + gtk_tree_model_get_iter_first (priv->model, &other)) + { + do + { + gtk_tree_model_get (priv->model, &other, + GD_MAIN_COLUMN_ID, &id, + -1); + if (g_strcmp0 (id, priv->last_selected_id) == 0) + { + g_free (id); + found = TRUE; + break; + } + g_free (id); + } + while (gtk_tree_model_iter_next (priv->model, &other)); + } + + if (!found) + { + other = *iter; + while (gtk_tree_model_iter_previous (priv->model, &other)) + { + gtk_tree_model_get (priv->model, &other, + GD_MAIN_COLUMN_SELECTED, &selected, + -1); + + if (selected) + { + found = TRUE; + break; + } + } + } + + if (!found) + { + other = *iter; + while (gtk_tree_model_iter_next (priv->model, &other)) + { + gtk_tree_model_get (priv->model, &other, + GD_MAIN_COLUMN_SELECTED, &selected, + -1); + if (selected) + { + found = TRUE; + break; + } + } + } + + if (found) + selection_mode_do_select_range (self, iter, &other); + else + { + /* no other selected element found, just select the iter */ + do_select_row (self, iter, TRUE); + } + + g_signal_emit (self, signals[VIEW_SELECTION_CHANGED], 0); +} + +static gboolean +toggle_selection_for_path (GdMainView *self, + GtkTreePath *path, + gboolean select_range) +{ + GdMainViewPrivate *priv; + gboolean selected; + GtkTreeIter iter; + char *id; + + priv = gd_main_view_get_instance_private (self); + + if (priv->model == NULL) + return FALSE; + + if (!gtk_tree_model_get_iter (priv->model, &iter, path)) + return FALSE; + + gtk_tree_model_get (priv->model, &iter, + GD_MAIN_COLUMN_SELECTED, &selected, + -1); + + if (selected) + { + do_select_row (self, &iter, FALSE); + } + else if (!selected) + { + if (select_range) + selection_mode_select_range (self, &iter); + else + { + gtk_tree_model_get (priv->model, &iter, + GD_MAIN_COLUMN_ID, &id, + -1); + g_free (priv->last_selected_id); + priv->last_selected_id = id; + + do_select_row (self, &iter, TRUE); + } + } + + g_signal_emit (self, signals[VIEW_SELECTION_CHANGED], 0); + + return FALSE; +} + +static gboolean +activate_item_for_path (GdMainView *self, + GtkTreePath *path) +{ + GdMainViewPrivate *priv; + GtkTreeIter iter; + gchar *id; + + priv = gd_main_view_get_instance_private (self); + + if (priv->model == NULL) + return FALSE; + + if (!gtk_tree_model_get_iter (priv->model, &iter, path)) + return FALSE; + + gtk_tree_model_get (priv->model, &iter, + GD_MAIN_COLUMN_ID, &id, + -1); + + g_signal_emit (self, signals[ITEM_ACTIVATED], 0, id, path); + g_free (id); + + return FALSE; +} + +static gboolean +on_button_release_selection_mode (GdMainView *self, + GdkEventButton *event, + GtkTreePath *path) +{ + return toggle_selection_for_path (self, path, ((event->state & GDK_SHIFT_MASK) != 0)); +} + +static gboolean +on_button_release_view_mode (GdMainView *self, + GdkEventButton *event, + GtkTreePath *path) +{ + return activate_item_for_path (self, path); +} + +static gboolean +event_triggers_selection_mode (GdkEventButton *event) +{ + return + (event->button == 3) || + ((event->button == 1) && (event->state & GDK_CONTROL_MASK)); +} + +static gboolean +on_button_release_event (GtkWidget *view, + GdkEventButton *event, + gpointer user_data) +{ + GdMainView *self = user_data; + GdMainViewPrivate *priv; + GdMainViewGeneric *generic = get_generic (self); + GtkTreePath *path, *start_path, *end_path, *tmp_path; + GtkTreeIter iter; + gchar *button_release_item_path; + gboolean selection_mode; + gboolean res, same_item = FALSE; + gboolean is_selected; + + priv = gd_main_view_get_instance_private (self); + + /* eat double/triple click events */ + if (event->type != GDK_BUTTON_RELEASE) + return TRUE; + + path = gd_main_view_generic_get_path_at_pos (generic, event->x, event->y); + + if (path != NULL) + { + button_release_item_path = gtk_tree_path_to_string (path); + if (g_strcmp0 (priv->button_press_item_path, button_release_item_path) == 0) + same_item = TRUE; + + g_free (button_release_item_path); + } + + g_free (priv->button_press_item_path); + priv->button_press_item_path = NULL; + + priv->track_motion = FALSE; + if (priv->rubberband_select) + { + priv->rubberband_select = FALSE; + gd_main_view_generic_set_rubberband_range (get_generic (self), NULL, NULL); + if (priv->rubberband_select_last_path) + { + if (!priv->selection_mode) + g_signal_emit (self, signals[SELECTION_MODE_REQUEST], 0); + if (!priv->selection_mode) + { + res = FALSE; + goto out; + } + + start_path = gtk_tree_path_copy (priv->rubberband_select_first_path); + end_path = gtk_tree_path_copy (priv->rubberband_select_last_path); + if (gtk_tree_path_compare (start_path, end_path) > 0) + { + tmp_path = start_path; + start_path = end_path; + end_path = tmp_path; + } + + while (gtk_tree_path_compare (start_path, end_path) <= 0) + { + if (gtk_tree_model_get_iter (priv->model, + &iter, start_path)) + { + gtk_tree_model_get (priv->model, &iter, + GD_MAIN_COLUMN_SELECTED, &is_selected, + -1); + do_select_row (self, &iter, !is_selected); + } + + gtk_tree_path_next (start_path); + } + + g_signal_emit (self, signals[VIEW_SELECTION_CHANGED], 0); + + gtk_tree_path_free (start_path); + gtk_tree_path_free (end_path); + } + + g_clear_pointer (&priv->rubberband_select_first_path, + gtk_tree_path_free); + g_clear_pointer (&priv->rubberband_select_last_path, + gtk_tree_path_free); + + res = TRUE; + goto out; + } + + if (!same_item) + { + res = FALSE; + goto out; + } + + selection_mode = priv->selection_mode; + + if (!selection_mode) + { + if (event_triggers_selection_mode (event)) + { + g_signal_emit (self, signals[SELECTION_MODE_REQUEST], 0); + if (!priv->selection_mode) + { + res = FALSE; + goto out; + } + selection_mode = priv->selection_mode; + } + } + + if (selection_mode) + res = on_button_release_selection_mode (self, event, path); + else + res = on_button_release_view_mode (self, event, path); + + out: + gtk_tree_path_free (path); + return res; +} + +static gboolean +on_button_press_event (GtkWidget *view, + GdkEventButton *event, + gpointer user_data) +{ + GdMainView *self = user_data; + GdMainViewPrivate *priv; + GdMainViewGeneric *generic = get_generic (self); + GtkTreePath *path; + GList *selection, *l; + GtkTreePath *sel_path; + gboolean found = FALSE; + gboolean force_selection; + + priv = gd_main_view_get_instance_private (self); + + path = gd_main_view_generic_get_path_at_pos (generic, event->x, event->y); + + if (path != NULL) + priv->button_press_item_path = gtk_tree_path_to_string (path); + + force_selection = event_triggers_selection_mode (event); + if (!priv->selection_mode && !force_selection) + { + gtk_tree_path_free (path); + return FALSE; + } + + if (path && !force_selection) + { + selection = gd_main_view_get_selection (self); + + for (l = selection; l != NULL; l = l->next) + { + sel_path = l->data; + if (gtk_tree_path_compare (path, sel_path) == 0) + { + found = TRUE; + break; + } + } + + if (selection != NULL) + g_list_free_full (selection, (GDestroyNotify) gtk_tree_path_free); + } + + /* if we did not find the item in the selection, block + * drag and drop, while in selection mode + */ + if (!found) + { + priv->track_motion = TRUE; + priv->rubberband_select = FALSE; + priv->rubberband_select_first_path = NULL; + priv->rubberband_select_last_path = NULL; + priv->button_down_x = event->x; + priv->button_down_y = event->y; + return TRUE; + } + else + return FALSE; +} + +static gboolean +on_motion_event (GtkWidget *widget, + GdkEventMotion *event, + gpointer user_data) +{ + GdMainView *self = user_data; + GdMainViewPrivate *priv; + GtkTreePath *path; + + priv = gd_main_view_get_instance_private (self); + + if (priv->track_motion) + { + if (!priv->rubberband_select && + (event->x - priv->button_down_x) * (event->x - priv->button_down_x) + + (event->y - priv->button_down_y) * (event->y - priv->button_down_y) > + MAIN_VIEW_RUBBERBAND_SELECT_TRIGGER_LENGTH * MAIN_VIEW_RUBBERBAND_SELECT_TRIGGER_LENGTH) + { + priv->rubberband_select = TRUE; + if (priv->button_press_item_path) + { + priv->rubberband_select_first_path = + gtk_tree_path_new_from_string (priv->button_press_item_path); + } + } + + if (priv->rubberband_select) + { + path = gd_main_view_generic_get_path_at_pos (get_generic (self), event->x, event->y); + if (path != NULL) + { + if (priv->rubberband_select_first_path == NULL) + priv->rubberband_select_first_path = gtk_tree_path_copy (path); + + if (priv->rubberband_select_last_path == NULL || + gtk_tree_path_compare (priv->rubberband_select_last_path, path) != 0) + { + if (priv->rubberband_select_last_path) + gtk_tree_path_free (priv->rubberband_select_last_path); + priv->rubberband_select_last_path = path; + + gd_main_view_generic_set_rubberband_range (get_generic (self), + priv->rubberband_select_first_path, + priv->rubberband_select_last_path); + } + else + gtk_tree_path_free (path); + } + } + } + return FALSE; +} + +static void +on_drag_begin (GdMainViewGeneric *generic, + GdkDragContext *drag_context, + gpointer user_data) +{ + GdMainView *self = user_data; + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + + if (priv->button_press_item_path != NULL) + { + gboolean res; + GtkTreeIter iter; + gpointer data; + cairo_surface_t *surface = NULL; + GtkTreePath *path; + GType column_gtype; + + path = gtk_tree_path_new_from_string (priv->button_press_item_path); + res = gtk_tree_model_get_iter (priv->model, + &iter, path); + if (res) + gtk_tree_model_get (priv->model, &iter, + GD_MAIN_COLUMN_ICON, &data, + -1); + + column_gtype = gtk_tree_model_get_column_type (priv->model, + GD_MAIN_COLUMN_ICON); + + if (column_gtype == CAIRO_GOBJECT_TYPE_SURFACE) + { + surface = gd_copy_image_surface (data); + cairo_surface_destroy (data); + } + else if (column_gtype == GDK_TYPE_PIXBUF) + { + surface = gdk_cairo_surface_create_from_pixbuf (data, 1, NULL); + g_object_unref (data); + } + else + g_assert_not_reached (); + + if (priv->selection_mode && + surface != NULL) + { + GList *selection; + cairo_surface_t *counter; + + selection = gd_main_view_get_selection (self); + + if (g_list_length (selection) > 1) + { + counter = gd_create_surface_with_counter (GTK_WIDGET (self), surface, g_list_length (selection)); + cairo_surface_destroy (surface); + surface = counter; + } + + if (selection != NULL) + g_list_free_full (selection, (GDestroyNotify) gtk_tree_path_free); + } + + if (surface != NULL) + { + cairo_surface_set_device_offset (surface, + -MAIN_VIEW_DND_ICON_OFFSET, + -MAIN_VIEW_DND_ICON_OFFSET); + gtk_drag_set_icon_surface (drag_context, surface); + cairo_surface_destroy (surface); + } + + gtk_tree_path_free (path); + } +} + +static void +on_view_path_activated (GdMainView *self, + GtkTreePath *path) +{ + GdMainViewPrivate *priv; + GdkModifierType state; + + priv = gd_main_view_get_instance_private (self); + + gtk_get_current_event_state (&state); + + if (priv->selection_mode || (state & GDK_CONTROL_MASK) != 0) + { + if (!priv->selection_mode) + g_signal_emit (self, signals[SELECTION_MODE_REQUEST], 0); + toggle_selection_for_path (self, path, ((state & GDK_SHIFT_MASK) != 0)); + } + else + activate_item_for_path (self, path); +} + +static void +on_list_view_row_activated (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column, + gpointer user_data) +{ + GdMainView *self = user_data; + on_view_path_activated (self, path); +} + +static void +on_icon_view_item_activated (GtkIconView *icon_view, + GtkTreePath *path, + gpointer user_data) +{ + GdMainView *self = user_data; + on_view_path_activated (self, path); +} + +static void +on_view_selection_changed (GtkWidget *view, + gpointer user_data) +{ + GdMainView *self = user_data; + + g_signal_emit (self, signals[VIEW_SELECTION_CHANGED], 0); +} + +static void +on_row_deleted_cb (GtkTreeModel *model, + GtkTreePath *path, + gpointer user_data) +{ + GdMainView *self = user_data; + + g_signal_emit (self, signals[VIEW_SELECTION_CHANGED], 0); +} + +static void +gd_main_view_apply_model (GdMainView *self) +{ + GdMainViewPrivate *priv; + GdMainViewGeneric *generic = get_generic (self); + + priv = gd_main_view_get_instance_private (self); + gd_main_view_generic_set_model (generic, priv->model); +} + +static void +gd_main_view_apply_selection_mode (GdMainView *self) +{ + GdMainViewPrivate *priv; + GdMainViewGeneric *generic = get_generic (self); + + priv = gd_main_view_get_instance_private (self); + + gd_main_view_generic_set_selection_mode (generic, priv->selection_mode); + + if (!priv->selection_mode) + { + g_clear_pointer (&priv->last_selected_id, g_free); + if (priv->model != NULL) + gd_main_view_unselect_all (self); + } +} + +static void +gd_main_view_rebuild (GdMainView *self) +{ + GdMainViewPrivate *priv; + GtkStyleContext *context; + + priv = gd_main_view_get_instance_private (self); + + if (priv->current_view != NULL) + gtk_widget_destroy (priv->current_view); + + if (priv->current_type == GD_MAIN_VIEW_ICON) + { + priv->current_view = gd_main_icon_view_new (); + g_signal_connect (priv->current_view, "item-activated", + G_CALLBACK (on_icon_view_item_activated), self); + } + else + { + priv->current_view = gd_main_list_view_new (); + g_signal_connect (priv->current_view, "row-activated", + G_CALLBACK (on_list_view_row_activated), self); + } + + context = gtk_widget_get_style_context (priv->current_view); + gtk_style_context_add_class (context, "content-view"); + + gtk_container_add (GTK_CONTAINER (self), priv->current_view); + + g_signal_connect (priv->current_view, "button-press-event", + G_CALLBACK (on_button_press_event), self); + g_signal_connect (priv->current_view, "button-release-event", + G_CALLBACK (on_button_release_event), self); + g_signal_connect (priv->current_view, "motion-notify-event", + G_CALLBACK (on_motion_event), self); + g_signal_connect_after (priv->current_view, "drag-begin", + G_CALLBACK (on_drag_begin), self); + g_signal_connect (priv->current_view, "view-selection-changed", + G_CALLBACK (on_view_selection_changed), self); + + gd_main_view_apply_model (self); + gd_main_view_apply_selection_mode (self); + + gtk_widget_show_all (GTK_WIDGET (self)); +} + +GdMainView * +gd_main_view_new (GdMainViewType type) +{ + return g_object_new (GD_TYPE_MAIN_VIEW, + "view-type", type, + NULL); +} + +void +gd_main_view_set_view_type (GdMainView *self, + GdMainViewType type) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + + if (type != priv->current_type) + { + priv->current_type = type; + gd_main_view_rebuild (self); + + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_VIEW_TYPE]); + } +} + +GdMainViewType +gd_main_view_get_view_type (GdMainView *self) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + return priv->current_type; +} + +void +gd_main_view_set_selection_mode (GdMainView *self, + gboolean selection_mode) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + + if (selection_mode != priv->selection_mode) + { + priv->selection_mode = selection_mode; + gd_main_view_apply_selection_mode (self); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SELECTION_MODE]); + } +} + +gboolean +gd_main_view_get_selection_mode (GdMainView *self) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + return priv->selection_mode; +} + +/** + * gd_main_view_set_model: + * @self: + * @model: (allow-none): + * + */ +void +gd_main_view_set_model (GdMainView *self, + GtkTreeModel *model) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + + if (model != priv->model) + { + if (priv->model) + g_signal_handlers_disconnect_by_func (priv->model, + on_row_deleted_cb, self); + + g_clear_object (&priv->model); + + if (model) + { + priv->model = g_object_ref (model); + g_signal_connect (priv->model, "row-deleted", + G_CALLBACK (on_row_deleted_cb), self); + } + else + { + priv->model = NULL; + } + + gd_main_view_apply_model (self); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MODEL]); + } +} + +/** + * gd_main_view_get_model: + * @self: + * + * Returns: (transfer none): + */ +GtkTreeModel * +gd_main_view_get_model (GdMainView *self) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + return priv->model; +} + +/** + * gd_main_view_get_generic_view: + * @self: + * + * Returns: (transfer none): + */ +GtkWidget * +gd_main_view_get_generic_view (GdMainView *self) +{ + GdMainViewPrivate *priv; + + priv = gd_main_view_get_instance_private (self); + return priv->current_view; +} + +static gboolean +build_selection_list_foreach (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer user_data) +{ + GList **sel = user_data; + gboolean is_selected; + + gtk_tree_model_get (model, iter, + GD_MAIN_COLUMN_SELECTED, &is_selected, + -1); + + if (is_selected) + *sel = g_list_prepend (*sel, gtk_tree_path_copy (path)); + + return FALSE; +} + +/** + * gd_main_view_get_selection: + * @self: + * + * Returns: (element-type GtkTreePath) (transfer full): + */ +GList * +gd_main_view_get_selection (GdMainView *self) +{ + GdMainViewPrivate *priv; + GList *retval = NULL; + + priv = gd_main_view_get_instance_private (self); + + gtk_tree_model_foreach (priv->model, + build_selection_list_foreach, + &retval); + + return g_list_reverse (retval); +} + +void +gd_main_view_select_all (GdMainView *self) +{ + GdMainViewGeneric *generic = get_generic (self); + + gd_main_view_generic_select_all (generic); +} + +void +gd_main_view_unselect_all (GdMainView *self) +{ + GdMainViewGeneric *generic = get_generic (self); + + gd_main_view_generic_unselect_all (generic); +} diff --git a/subprojects/libgd/libgd/gd-main-view.h b/subprojects/libgd/libgd/gd-main-view.h new file mode 100644 index 0000000..4f8afe7 --- /dev/null +++ b/subprojects/libgd/libgd/gd-main-view.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef __GD_MAIN_VIEW_H__ +#define __GD_MAIN_VIEW_H__ + +#include + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_MAIN_VIEW gd_main_view_get_type() +G_DECLARE_DERIVABLE_TYPE (GdMainView, gd_main_view, GD, MAIN_VIEW, GtkScrolledWindow) + +typedef enum { + GD_MAIN_VIEW_ICON, + GD_MAIN_VIEW_LIST +} GdMainViewType; + +struct _GdMainViewClass { + GtkScrolledWindowClass parent_class; +}; + +GdMainView * gd_main_view_new (GdMainViewType type); +void gd_main_view_set_view_type (GdMainView *self, + GdMainViewType type); +GdMainViewType gd_main_view_get_view_type (GdMainView *self); + +void gd_main_view_set_selection_mode (GdMainView *self, + gboolean selection_mode); +gboolean gd_main_view_get_selection_mode (GdMainView *self); + +GList * gd_main_view_get_selection (GdMainView *self); + +void gd_main_view_select_all (GdMainView *self); +void gd_main_view_unselect_all (GdMainView *self); + +GtkTreeModel * gd_main_view_get_model (GdMainView *self); +void gd_main_view_set_model (GdMainView *self, + GtkTreeModel *model); + +GtkWidget * gd_main_view_get_generic_view (GdMainView *self); + +G_END_DECLS + +#endif /* __GD_MAIN_VIEW_H__ */ diff --git a/subprojects/libgd/libgd/gd-margin-container.c b/subprojects/libgd/libgd/gd-margin-container.c new file mode 100644 index 0000000..20f2046 --- /dev/null +++ b/subprojects/libgd/libgd/gd-margin-container.c @@ -0,0 +1,377 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "config.h" + +#include "gd-margin-container.h" + +G_DEFINE_TYPE_WITH_CODE (GdMarginContainer, gd_margin_container, GTK_TYPE_BIN, + G_ADD_PRIVATE (GdMarginContainer) + G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, + NULL)) + +struct _GdMarginContainerPrivate { + gint min_margin; + gint max_margin; + + GtkOrientation orientation; +}; + +enum { + PROP_MIN_MARGIN = 1, + PROP_MAX_MARGIN, + PROP_ORIENTATION, + NUM_PROPERTIES +}; + +static void +gd_margin_container_queue_redraw (GdMarginContainer *self) +{ + GtkWidget *child; + + /* Make sure that the widget and children are redrawn with the new setting: */ + child = gtk_bin_get_child (GTK_BIN (self)); + if (child) + gtk_widget_queue_resize (child); + + gtk_widget_queue_draw (GTK_WIDGET (self)); +} + +static void +gd_margin_container_set_orientation (GdMarginContainer *self, + GtkOrientation orientation) +{ + if (self->priv->orientation != orientation) + { + self->priv->orientation = orientation; + g_object_notify (G_OBJECT (self), "orientation"); + + gd_margin_container_queue_redraw (self); + } +} + +static void +gd_margin_container_set_min_margin (GdMarginContainer *self, + gint min_margin) +{ + if (self->priv->min_margin != min_margin) + { + self->priv->min_margin = min_margin; + g_object_notify (G_OBJECT (self), "min-margin"); + + gd_margin_container_queue_redraw (self); + } +} + +static void +gd_margin_container_set_max_margin (GdMarginContainer *self, + gint max_margin) +{ + if (self->priv->max_margin != max_margin) + { + self->priv->max_margin = max_margin; + g_object_notify (G_OBJECT (self), "max-margin"); + + gd_margin_container_queue_redraw (self); + } +} + +static void +gd_margin_container_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GdMarginContainer *self = GD_MARGIN_CONTAINER (object); + + switch (property_id) + { + case PROP_MIN_MARGIN: + gd_margin_container_set_min_margin (self, g_value_get_int (value)); + break; + case PROP_MAX_MARGIN: + gd_margin_container_set_max_margin (self, g_value_get_int (value)); + break; + case PROP_ORIENTATION: + gd_margin_container_set_orientation (self, g_value_get_enum (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_margin_container_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GdMarginContainer *self = GD_MARGIN_CONTAINER (object); + + switch (property_id) + { + case PROP_MIN_MARGIN: + g_value_set_int (value, self->priv->min_margin); + break; + case PROP_MAX_MARGIN: + g_value_set_int (value, self->priv->max_margin); + break; + case PROP_ORIENTATION: + g_value_set_enum (value, self->priv->orientation); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_margin_container_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + GdMarginContainer *self = GD_MARGIN_CONTAINER (widget); + GtkWidget *child; + GtkAllocation child_allocation; + gint avail_width, avail_height; + + child = gtk_bin_get_child (GTK_BIN (widget)); + gtk_widget_set_allocation (widget, allocation); + + if (child && gtk_widget_get_visible (child)) + { + gint child_nat_width; + gint child_nat_height; + gint child_width, child_height; + gint offset; + + /* available */ + avail_width = allocation->width; + avail_height = allocation->height; + + if (self->priv->orientation == GTK_ORIENTATION_HORIZONTAL) + avail_width = MAX (1, avail_width - 2 * self->priv->min_margin); + else + avail_height = MAX (1, avail_height - 2 * self->priv->min_margin); + + if (gtk_widget_get_request_mode (child) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH) + { + gtk_widget_get_preferred_width (child, NULL, &child_nat_width); + child_width = MIN (avail_width, child_nat_width); + + gtk_widget_get_preferred_height_for_width (child, child_width, NULL, &child_nat_height); + child_height = MIN (avail_height, child_nat_height); + + offset = MIN ((gint) ((avail_height - child_height) / 2), self->priv->max_margin); + + if (offset > 0) + child_allocation.height = avail_height - (offset * 2); + else + child_allocation.height = avail_height; + + child_allocation.width = MIN (avail_width, child_nat_width); + } + else + { + gtk_widget_get_preferred_height (child, NULL, &child_nat_height); + child_height = MIN (avail_height, child_nat_height); + + gtk_widget_get_preferred_width_for_height (child, child_height, NULL, &child_nat_width); + child_width = MIN (avail_width, child_nat_width); + + offset = MIN ((gint) ((avail_width - child_width) / 2), self->priv->max_margin); + + if (offset > 0) + child_allocation.width = avail_width - (offset * 2); + else + child_allocation.width = avail_width; + + child_allocation.height = MIN (avail_height, child_nat_height); + } + + child_allocation.x = offset + allocation->x; + child_allocation.y = (avail_height - child_allocation.height) + allocation->y; + + if (self->priv->orientation == GTK_ORIENTATION_HORIZONTAL) + child_allocation.x += self->priv->min_margin; + else + child_allocation.y += self->priv->min_margin; + + gtk_widget_size_allocate (child, &child_allocation); + } +} + +static void +gd_margin_container_get_preferred_size (GtkWidget *widget, + GtkOrientation orientation, + gint for_size, + gint *minimum_size, + gint *natural_size) +{ + GdMarginContainer *self = GD_MARGIN_CONTAINER (widget); + guint natural, minimum; + GtkWidget *child; + + if (orientation == self->priv->orientation) + { + minimum = self->priv->min_margin * 2; + natural = self->priv->max_margin * 2; + } + else + { + minimum = 0; + natural = 0; + } + + if ((child = gtk_bin_get_child (GTK_BIN (widget))) && gtk_widget_get_visible (child)) + { + gint child_min, child_nat; + + if (orientation == GTK_ORIENTATION_HORIZONTAL) + { + if (for_size < 0) + gtk_widget_get_preferred_width (child, &child_min, &child_nat); + else + { + gint min_height; + + gtk_widget_get_preferred_height (child, &min_height, NULL); + for_size -= 2 * self->priv->min_margin; + + gtk_widget_get_preferred_width_for_height (child, for_size, &child_min, &child_nat); + } + } + else + { + if (for_size < 0) + gtk_widget_get_preferred_height (child, &child_min, &child_nat); + else + { + gint min_width; + + gtk_widget_get_preferred_width (child, &min_width, NULL); + for_size -= 2 * self->priv->min_margin; + + gtk_widget_get_preferred_height_for_width (child, for_size, &child_min, &child_nat); + } + } + + natural += child_nat; + + if (orientation != self->priv->orientation) + minimum += child_min; + } + + if (minimum_size != NULL) + *minimum_size = minimum; + if (natural_size != NULL) + *natural_size = natural; +} + +static void +gd_margin_container_get_preferred_width (GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + gd_margin_container_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, + -1, minimum_size, natural_size); +} + +static void +gd_margin_container_get_preferred_height (GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + gd_margin_container_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, + -1, minimum_size, natural_size); +} + +static void +gd_margin_container_get_preferred_width_for_height (GtkWidget *widget, + gint for_size, + gint *minimum_size, + gint *natural_size) +{ + gd_margin_container_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, + for_size, minimum_size, natural_size); +} + +static void +gd_margin_container_get_preferred_height_for_width (GtkWidget *widget, + gint for_size, + gint *minimum_size, + gint *natural_size) +{ + gd_margin_container_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, + for_size, minimum_size, natural_size); +} + +static void +gd_margin_container_init (GdMarginContainer *self) +{ + self->priv = gd_margin_container_get_instance_private (self); + + self->priv->orientation = GTK_ORIENTATION_HORIZONTAL; + + gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); + gtk_widget_set_redraw_on_allocate (GTK_WIDGET (self), FALSE); +} + +static void +gd_margin_container_class_init (GdMarginContainerClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + GtkWidgetClass *wclass = GTK_WIDGET_CLASS (klass); + + oclass->get_property = gd_margin_container_get_property; + oclass->set_property = gd_margin_container_set_property; + + wclass->size_allocate = gd_margin_container_size_allocate; + wclass->get_preferred_width = gd_margin_container_get_preferred_width; + wclass->get_preferred_height = gd_margin_container_get_preferred_height; + wclass->get_preferred_width_for_height = gd_margin_container_get_preferred_width_for_height; + wclass->get_preferred_height_for_width = gd_margin_container_get_preferred_height_for_width; + + gtk_container_class_handle_border_width (GTK_CONTAINER_CLASS (klass)); + + g_object_class_install_property (oclass, PROP_MIN_MARGIN, + g_param_spec_int ("min-margin", + "Min margin", + "Minimum margin around the child", + 0, G_MAXINT, 6, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + g_object_class_install_property (oclass, PROP_MAX_MARGIN, + g_param_spec_int ("max-margin", + "Max margin", + "Maximum margin around the child", + 0, G_MAXINT, 6, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + g_object_class_override_property (oclass, PROP_ORIENTATION, + "orientation"); +} + +GdMarginContainer * +gd_margin_container_new (void) +{ + return g_object_new (GD_TYPE_MARGIN_CONTAINER, NULL); +} diff --git a/subprojects/libgd/libgd/gd-margin-container.h b/subprojects/libgd/libgd/gd-margin-container.h new file mode 100644 index 0000000..3937ea7 --- /dev/null +++ b/subprojects/libgd/libgd/gd-margin-container.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef _GD_MARGIN_CONTAINER_H +#define _GD_MARGIN_CONTAINER_H + +#include + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_MARGIN_CONTAINER gd_margin_container_get_type() + +#define GD_MARGIN_CONTAINER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ + GD_TYPE_MARGIN_CONTAINER, GdMarginContainer)) + +#define GD_MARGIN_CONTAINER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), \ + GD_TYPE_MARGIN_CONTAINER, GdMarginContainerClass)) + +#define GD_IS_MARGIN_CONTAINER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \ + GD_TYPE_MARGIN_CONTAINER)) + +#define GD_IS_MARGIN_CONTAINER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), \ + GD_TYPE_MARGIN_CONTAINER)) + +#define GD_MARGIN_CONTAINER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), \ + GD_TYPE_MARGIN_CONTAINER, GdMarginContainerClass)) + +typedef struct _GdMarginContainer GdMarginContainer; +typedef struct _GdMarginContainerClass GdMarginContainerClass; +typedef struct _GdMarginContainerPrivate GdMarginContainerPrivate; + +struct _GdMarginContainer +{ + GtkBin parent; + + GdMarginContainerPrivate *priv; +}; + +struct _GdMarginContainerClass +{ + GtkBinClass parent_class; +}; + +GType gd_margin_container_get_type (void) G_GNUC_CONST; + +GdMarginContainer *gd_margin_container_new (void); + +G_END_DECLS + +#endif /* _GD_MARGIN_CONTAINER_H */ diff --git a/subprojects/libgd/libgd/gd-notification.c b/subprojects/libgd/libgd/gd-notification.c new file mode 100644 index 0000000..ba006fa --- /dev/null +++ b/subprojects/libgd/libgd/gd-notification.c @@ -0,0 +1,870 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * gd-notification + * Based on gtk-notification from gnome-contacts: + * http://git.gnome.org/browse/gnome-contacts/tree/src/gtk-notification.c?id=3.3.91 + * + * Copyright (C) Erick Pérez Castellanos 2011 + * Copyright (C) 2012 Red Hat, Inc. + * + * This program is free software: you can redistribute 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see ."; + */ + +#include "gd-notification.h" + +/** + * SECTION:gdnotification + * @short_description: Report notification messages to the user + * @include: gtk/gtk.h + * @see_also: #GtkStatusbar, #GtkMessageDialog, #GtkInfoBar + * + * #GdNotification is a widget made for showing notifications to + * the user, allowing them to close the notification or wait for it + * to time out. + * + * #GdNotification provides one signal (#GdNotification::dismissed), for when the notification + * times out or is closed. + * + */ + +#define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB +#define SHADOW_OFFSET_X 2 +#define SHADOW_OFFSET_Y 3 +#define ANIMATION_TIME 200 /* msec */ +#define ANIMATION_STEP 40 /* msec */ + +enum { + PROP_0, + PROP_TIMEOUT, + PROP_SHOW_CLOSE_BUTTON +}; + +struct _GdNotificationPrivate { + GtkWidget *close_button; + gboolean show_close_button; + + GdkWindow *bin_window; + + int animate_y; /* from 0 to allocation.height */ + gboolean waiting_for_viewable; + gboolean revealed; + gboolean dismissed; + gboolean sent_dismissed; + guint animate_timeout; + + gint timeout; + guint timeout_source_id; +}; + +enum { + DISMISSED, + LAST_SIGNAL +}; + +static guint notification_signals[LAST_SIGNAL] = { 0 }; + +static gboolean gd_notification_draw (GtkWidget *widget, + cairo_t *cr); +static void gd_notification_get_preferred_width (GtkWidget *widget, + gint *minimum_size, + gint *natural_size); +static void gd_notification_get_preferred_height_for_width (GtkWidget *widget, + gint width, + gint *minimum_height, + gint *natural_height); +static void gd_notification_get_preferred_height (GtkWidget *widget, + gint *minimum_size, + gint *natural_size); +static void gd_notification_get_preferred_width_for_height (GtkWidget *widget, + gint height, + gint *minimum_width, + gint *natural_width); +static void gd_notification_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); +static gboolean gd_notification_timeout_cb (gpointer user_data); +static void gd_notification_show (GtkWidget *widget); +static void gd_notification_add (GtkContainer *container, + GtkWidget *child); + +/* signals handlers */ +static void gd_notification_close_button_clicked_cb (GtkWidget *widget, + gpointer user_data); + +G_DEFINE_TYPE_WITH_PRIVATE (GdNotification, gd_notification, GTK_TYPE_BIN) + +static void +gd_notification_init (GdNotification *notification) +{ + GtkWidget *close_button_image; + GtkStyleContext *context; + GdNotificationPrivate *priv; + + context = gtk_widget_get_style_context (GTK_WIDGET (notification)); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_FRAME); + gtk_style_context_add_class (context, "app-notification"); + + gtk_widget_set_halign (GTK_WIDGET (notification), GTK_ALIGN_CENTER); + gtk_widget_set_valign (GTK_WIDGET (notification), GTK_ALIGN_START); + + gtk_widget_set_has_window (GTK_WIDGET (notification), TRUE); + + priv = notification->priv = gd_notification_get_instance_private (notification); + + priv->animate_y = 0; + priv->close_button = gtk_button_new (); + gtk_widget_set_parent (priv->close_button, GTK_WIDGET (notification)); + gtk_widget_show (priv->close_button); + g_object_set (priv->close_button, + "relief", GTK_RELIEF_NONE, + "focus-on-click", FALSE, + NULL); + g_signal_connect (priv->close_button, + "clicked", + G_CALLBACK (gd_notification_close_button_clicked_cb), + notification); + close_button_image = gtk_image_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_BUTTON); + gtk_button_set_image (GTK_BUTTON (notification->priv->close_button), close_button_image); + + priv->timeout_source_id = 0; +} + +static void +gd_notification_finalize (GObject *object) +{ + GdNotification *notification; + GdNotificationPrivate *priv; + + g_return_if_fail (GTK_IS_NOTIFICATION (object)); + + notification = GD_NOTIFICATION (object); + priv = notification->priv; + + if (priv->animate_timeout != 0) + g_source_remove (priv->animate_timeout); + + if (priv->timeout_source_id != 0) + g_source_remove (priv->timeout_source_id); + + G_OBJECT_CLASS (gd_notification_parent_class)->finalize (object); +} + +static void +gd_notification_destroy (GtkWidget *widget) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + + if (!priv->sent_dismissed) + { + g_signal_emit (notification, notification_signals[DISMISSED], 0); + priv->sent_dismissed = TRUE; + } + + if (priv->close_button) + { + gtk_widget_unparent (priv->close_button); + priv->close_button = NULL; + } + + GTK_WIDGET_CLASS (gd_notification_parent_class)->destroy (widget); +} + +static void +gd_notification_realize (GtkWidget *widget) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + GtkBin *bin = GTK_BIN (widget); + GtkAllocation allocation; + GtkWidget *child; + GdkWindow *window; + GdkWindowAttr attributes; + gint attributes_mask; + + gtk_widget_set_realized (widget, TRUE); + + gtk_widget_get_allocation (widget, &allocation); + + attributes.x = allocation.x; + attributes.y = allocation.y; + attributes.width = allocation.width; + attributes.height = allocation.height; + attributes.window_type = GDK_WINDOW_CHILD; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gtk_widget_get_visual (widget); + + attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK; + + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; + + window = gdk_window_new (gtk_widget_get_parent_window (widget), + &attributes, attributes_mask); + gtk_widget_set_window (widget, window); + gtk_widget_register_window (widget, window); + + attributes.x = 0; + attributes.y = attributes.height + priv->animate_y; + attributes.event_mask = gtk_widget_get_events (widget) | + GDK_EXPOSURE_MASK | + GDK_VISIBILITY_NOTIFY_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK; + + priv->bin_window = gdk_window_new (window, &attributes, attributes_mask); + gtk_widget_register_window (widget, priv->bin_window); + + child = gtk_bin_get_child (bin); + if (child) + gtk_widget_set_parent_window (child, priv->bin_window); + gtk_widget_set_parent_window (priv->close_button, priv->bin_window); + + gdk_window_show (priv->bin_window); +} + +static void +gd_notification_unrealize (GtkWidget *widget) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + + gtk_widget_unregister_window (widget, priv->bin_window); + gdk_window_destroy (priv->bin_window); + priv->bin_window = NULL; + + GTK_WIDGET_CLASS (gd_notification_parent_class)->unrealize (widget); +} + +static int +animation_target (GdNotification *notification) +{ + GdNotificationPrivate *priv = notification->priv; + GtkAllocation allocation; + + if (priv->revealed) { + gtk_widget_get_allocation (GTK_WIDGET (notification), &allocation); + return allocation.height; + } else { + return 0; + } +} + +static gboolean +animation_timeout_cb (gpointer user_data) +{ + GdNotification *notification = GD_NOTIFICATION (user_data); + GdNotificationPrivate *priv = notification->priv; + GtkAllocation allocation; + int target, delta; + + target = animation_target (notification); + + if (priv->animate_y != target) { + gtk_widget_get_allocation (GTK_WIDGET (notification), &allocation); + + delta = allocation.height * ANIMATION_STEP / ANIMATION_TIME; + + if (priv->revealed) + priv->animate_y += delta; + else + priv->animate_y -= delta; + + priv->animate_y = CLAMP (priv->animate_y, 0, allocation.height); + + if (priv->bin_window != NULL) + gdk_window_move (priv->bin_window, + 0, + -allocation.height + priv->animate_y); + return G_SOURCE_CONTINUE; + } + + if (priv->dismissed && priv->animate_y == 0) + gtk_widget_destroy (GTK_WIDGET (notification)); + + priv->animate_timeout = 0; + return G_SOURCE_REMOVE; +} + +static void +start_animation (GdNotification *notification) +{ + GdNotificationPrivate *priv = notification->priv; + int target; + + if (priv->animate_timeout != 0) + return; /* Already running */ + + target = animation_target (notification); + if (priv->animate_y != target) + notification->priv->animate_timeout = + gdk_threads_add_timeout (ANIMATION_STEP, + animation_timeout_cb, + notification); +} + +static void +gd_notification_show (GtkWidget *widget) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + + GTK_WIDGET_CLASS (gd_notification_parent_class)->show (widget); + priv->revealed = TRUE; + priv->waiting_for_viewable = TRUE; +} + +static void +gd_notification_hide (GtkWidget *widget) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + + GTK_WIDGET_CLASS (gd_notification_parent_class)->hide (widget); + priv->revealed = FALSE; + priv->waiting_for_viewable = FALSE; +} + +static void +gd_notification_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +{ + GdNotification *notification = GD_NOTIFICATION (object); + + g_return_if_fail (GTK_IS_NOTIFICATION (object)); + + switch (prop_id) { + case PROP_TIMEOUT: + gd_notification_set_timeout (notification, + g_value_get_int (value)); + break; + case PROP_SHOW_CLOSE_BUTTON: + gd_notification_set_show_close_button (notification, + g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gd_notification_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +{ + g_return_if_fail (GTK_IS_NOTIFICATION (object)); + GdNotification *notification = GD_NOTIFICATION (object); + + switch (prop_id) { + case PROP_TIMEOUT: + g_value_set_int (value, notification->priv->timeout); + break; + case PROP_SHOW_CLOSE_BUTTON: + g_value_set_boolean (value, + notification->priv->show_close_button); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gd_notification_forall (GtkContainer *container, + gboolean include_internals, + GtkCallback callback, + gpointer callback_data) +{ + GtkBin *bin = GTK_BIN (container); + GdNotification *notification = GD_NOTIFICATION (container); + GdNotificationPrivate *priv = notification->priv; + GtkWidget *child; + + child = gtk_bin_get_child (bin); + if (child) + (* callback) (child, callback_data); + + if (include_internals) + (* callback) (priv->close_button, callback_data); +} + +static void +unqueue_autohide (GdNotification *notification) +{ + GdNotificationPrivate *priv = notification->priv; + + if (priv->timeout_source_id) + { + g_source_remove (priv->timeout_source_id); + priv->timeout_source_id = 0; + } +} + +static void +queue_autohide (GdNotification *notification) +{ + GdNotificationPrivate *priv = notification->priv; + + if (priv->timeout_source_id == 0 && + priv->timeout != -1) + priv->timeout_source_id = + gdk_threads_add_timeout (priv->timeout * 1000, + gd_notification_timeout_cb, + notification); +} + +static gboolean +gd_notification_visibility_notify_event (GtkWidget *widget, + GdkEventVisibility *event) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + + if (!gtk_widget_get_visible (widget)) + return FALSE; + + if (priv->waiting_for_viewable) + { + start_animation (notification); + priv->waiting_for_viewable = FALSE; + } + + queue_autohide (notification); + + return FALSE; +} + +static gboolean +gd_notification_enter_notify (GtkWidget *widget, + GdkEventCrossing *event) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + + if ((event->window == priv->bin_window) && + (event->detail != GDK_NOTIFY_INFERIOR)) + { + unqueue_autohide (notification); + } + + return FALSE; +} + +static gboolean +gd_notification_leave_notify (GtkWidget *widget, + GdkEventCrossing *event) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + + if ((event->window == priv->bin_window) && + (event->detail != GDK_NOTIFY_INFERIOR)) + { + queue_autohide (notification); + } + + return FALSE; +} + +static void +gd_notification_class_init (GdNotificationClass *klass) +{ + GObjectClass* object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass); + GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); + + object_class->finalize = gd_notification_finalize; + object_class->set_property = gd_notification_set_property; + object_class->get_property = gd_notification_get_property; + + widget_class->show = gd_notification_show; + widget_class->hide = gd_notification_hide; + widget_class->destroy = gd_notification_destroy; + widget_class->get_preferred_width = gd_notification_get_preferred_width; + widget_class->get_preferred_height_for_width = gd_notification_get_preferred_height_for_width; + widget_class->get_preferred_height = gd_notification_get_preferred_height; + widget_class->get_preferred_width_for_height = gd_notification_get_preferred_width_for_height; + widget_class->size_allocate = gd_notification_size_allocate; + widget_class->draw = gd_notification_draw; + widget_class->realize = gd_notification_realize; + widget_class->unrealize = gd_notification_unrealize; + widget_class->visibility_notify_event = gd_notification_visibility_notify_event; + widget_class->enter_notify_event = gd_notification_enter_notify; + widget_class->leave_notify_event = gd_notification_leave_notify; + + container_class->add = gd_notification_add; + container_class->forall = gd_notification_forall; + gtk_container_class_handle_border_width (container_class); + + + /** + * GdNotification:timeout: + * + * The time it takes to hide the widget, in seconds. + * + * Since: 0.1 + */ + g_object_class_install_property (object_class, + PROP_TIMEOUT, + g_param_spec_int("timeout", "timeout", + "The time it takes to hide the widget, in seconds", + -1, G_MAXINT, -1, + GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + g_object_class_install_property (object_class, + PROP_SHOW_CLOSE_BUTTON, + g_param_spec_boolean("show-close-button", "show-close-button", + "Whether to show a stock close button that dismisses the notification", + TRUE, + GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + notification_signals[DISMISSED] = g_signal_new ("dismissed", + G_OBJECT_CLASS_TYPE (klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GdNotificationClass, dismissed), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); +} + +static void +get_padding_and_border (GdNotification *notification, + GtkBorder *border) +{ + GtkStyleContext *context; + GtkStateFlags state; + GtkBorder tmp; + + context = gtk_widget_get_style_context (GTK_WIDGET (notification)); + state = gtk_widget_get_state_flags (GTK_WIDGET (notification)); + + gtk_style_context_get_padding (context, state, border); + + gtk_style_context_get_border (context, state, &tmp); + border->top += tmp.top; + border->right += tmp.right; + border->bottom += tmp.bottom; + border->left += tmp.left; +} + +static gboolean +gd_notification_draw (GtkWidget *widget, cairo_t *cr) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + GtkStyleContext *context; + + if (gtk_cairo_should_draw_window (cr, priv->bin_window)) + { + context = gtk_widget_get_style_context (widget); + + gtk_render_background (context, cr, + 0, 0, + gtk_widget_get_allocated_width (widget), + gtk_widget_get_allocated_height (widget)); + gtk_render_frame (context,cr, + 0, 0, + gtk_widget_get_allocated_width (widget), + gtk_widget_get_allocated_height (widget)); + + + if (GTK_WIDGET_CLASS (gd_notification_parent_class)->draw) + GTK_WIDGET_CLASS (gd_notification_parent_class)->draw(widget, cr); + } + + return FALSE; +} + +static void +gd_notification_add (GtkContainer *container, + GtkWidget *child) +{ + GtkBin *bin = GTK_BIN (container); + GdNotification *notification = GD_NOTIFICATION (bin); + GdNotificationPrivate *priv = notification->priv; + + g_return_if_fail (gtk_bin_get_child (bin) == NULL); + + gtk_widget_set_parent_window (child, priv->bin_window); + + GTK_CONTAINER_CLASS (gd_notification_parent_class)->add (container, child); +} + + +static void +gd_notification_get_preferred_width (GtkWidget *widget, gint *minimum_size, gint *natural_size) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + GtkBin *bin = GTK_BIN (widget); + gint child_min, child_nat; + GtkWidget *child; + GtkBorder padding; + gint minimum, natural; + + get_padding_and_border (notification, &padding); + + minimum = 0; + natural = 0; + + child = gtk_bin_get_child (bin); + if (child && gtk_widget_get_visible (child)) + { + gtk_widget_get_preferred_width (child, + &child_min, &child_nat); + minimum += child_min; + natural += child_nat; + } + + if (priv->show_close_button) + { + gtk_widget_get_preferred_width (priv->close_button, + &child_min, &child_nat); + minimum += child_min; + natural += child_nat; + } + + minimum += padding.left + padding.right + 2 * SHADOW_OFFSET_X; + natural += padding.left + padding.right + 2 * SHADOW_OFFSET_X; + + if (minimum_size) + *minimum_size = minimum; + + if (natural_size) + *natural_size = natural; +} + +static void +gd_notification_get_preferred_width_for_height (GtkWidget *widget, + gint height, + gint *minimum_width, + gint *natural_width) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + GtkBin *bin = GTK_BIN (widget); + gint child_min, child_nat, child_height; + GtkWidget *child; + GtkBorder padding; + gint minimum, natural; + + get_padding_and_border (notification, &padding); + + minimum = 0; + natural = 0; + + child_height = height - SHADOW_OFFSET_Y - padding.top - padding.bottom; + + child = gtk_bin_get_child (bin); + if (child && gtk_widget_get_visible (child)) + { + gtk_widget_get_preferred_width_for_height (child, child_height, + &child_min, &child_nat); + minimum += child_min; + natural += child_nat; + } + + if (priv->show_close_button) + { + gtk_widget_get_preferred_width_for_height (priv->close_button, child_height, + &child_min, &child_nat); + minimum += child_min; + natural += child_nat; + } + + minimum += padding.left + padding.right + 2 * SHADOW_OFFSET_X; + natural += padding.left + padding.right + 2 * SHADOW_OFFSET_X; + + if (minimum_width) + *minimum_width = minimum; + + if (natural_width) + *natural_width = natural; +} + +static void +gd_notification_get_preferred_height_for_width (GtkWidget *widget, + gint width, + gint *minimum_height, + gint *natural_height) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + GtkBin *bin = GTK_BIN (widget); + gint child_min, child_nat, child_width, button_width = 0; + GtkWidget *child; + GtkBorder padding; + gint minimum = 0, natural = 0; + + get_padding_and_border (notification, &padding); + + if (priv->show_close_button) + { + gtk_widget_get_preferred_height (priv->close_button, + &minimum, &natural); + gtk_widget_get_preferred_width (priv->close_button, + NULL, &button_width); + } + + child = gtk_bin_get_child (bin); + if (child && gtk_widget_get_visible (child)) + { + child_width = width - button_width - + 2 * SHADOW_OFFSET_X - padding.left - padding.right; + + gtk_widget_get_preferred_height_for_width (child, child_width, + &child_min, &child_nat); + minimum = MAX (minimum, child_min); + natural = MAX (natural, child_nat); + } + + minimum += padding.top + padding.bottom + SHADOW_OFFSET_Y; + natural += padding.top + padding.bottom + SHADOW_OFFSET_Y; + + if (minimum_height) + *minimum_height = minimum; + + if (natural_height) + *natural_height = natural; +} + +static void +gd_notification_get_preferred_height (GtkWidget *widget, + gint *minimum_height, + gint *natural_height) +{ + gint width; + + gd_notification_get_preferred_width (widget, &width, NULL); + gd_notification_get_preferred_height_for_width (widget, width, + minimum_height, natural_height); +} + +static void +gd_notification_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + GdNotification *notification = GD_NOTIFICATION (widget); + GdNotificationPrivate *priv = notification->priv; + GtkBin *bin = GTK_BIN (widget); + GtkAllocation child_allocation; + GtkBorder padding; + GtkRequisition button_req; + GtkWidget *child; + + gtk_widget_set_allocation (widget, allocation); + + /* If somehow the notification changes while not hidden + and we're not animating, immediately follow the resize */ + if (priv->animate_y > 0 && + !priv->animate_timeout) + priv->animate_y = allocation->height; + + get_padding_and_border (notification, &padding); + + if (gtk_widget_get_realized (widget)) + { + gdk_window_move_resize (gtk_widget_get_window (widget), + allocation->x, + allocation->y, + allocation->width, + allocation->height); + gdk_window_move_resize (priv->bin_window, + 0, + -allocation->height + priv->animate_y, + allocation->width, + allocation->height); + } + + child_allocation.x = SHADOW_OFFSET_X + padding.left; + child_allocation.y = padding.top; + + if (priv->show_close_button) + gtk_widget_get_preferred_size (priv->close_button, &button_req, NULL); + else + button_req.width = button_req.height = 0; + + child_allocation.height = MAX (1, allocation->height - SHADOW_OFFSET_Y - padding.top - padding.bottom); + child_allocation.width = MAX (1, (allocation->width - button_req.width - + 2 * SHADOW_OFFSET_X - padding.left - padding.right)); + + child = gtk_bin_get_child (bin); + if (child && gtk_widget_get_visible (child)) + gtk_widget_size_allocate (child, &child_allocation); + + if (priv->show_close_button) + { + child_allocation.x += child_allocation.width; + child_allocation.width = button_req.width; + child_allocation.y += (child_allocation.height - button_req.height) / 2; + child_allocation.height = button_req.height; + + gtk_widget_size_allocate (priv->close_button, &child_allocation); + } +} + +static gboolean +gd_notification_timeout_cb (gpointer user_data) +{ + GdNotification *notification = GD_NOTIFICATION (user_data); + + gd_notification_dismiss (notification); + + return G_SOURCE_REMOVE; +} + +void +gd_notification_set_timeout (GdNotification *notification, + gint timeout_sec) +{ + GdNotificationPrivate *priv = notification->priv; + + priv->timeout = timeout_sec; + g_object_notify (G_OBJECT (notification), "timeout"); +} + +void +gd_notification_set_show_close_button (GdNotification *notification, + gboolean show_close_button) +{ + GdNotificationPrivate *priv = notification->priv; + + priv->show_close_button = show_close_button; + + gtk_widget_set_visible (priv->close_button, show_close_button); + gtk_widget_queue_resize (GTK_WIDGET (notification)); +} + +void +gd_notification_dismiss (GdNotification *notification) +{ + GdNotificationPrivate *priv = notification->priv; + + unqueue_autohide (notification); + + priv->dismissed = TRUE; + priv->revealed = FALSE; + start_animation (notification); +} + +static void +gd_notification_close_button_clicked_cb (GtkWidget *widget, gpointer user_data) +{ + GdNotification *notification = GD_NOTIFICATION(user_data); + + gd_notification_dismiss (notification); +} + +GtkWidget * +gd_notification_new (void) +{ + return g_object_new (GD_TYPE_NOTIFICATION, NULL); +} diff --git a/subprojects/libgd/libgd/gd-notification.h b/subprojects/libgd/libgd/gd-notification.h new file mode 100644 index 0000000..8efa191 --- /dev/null +++ b/subprojects/libgd/libgd/gd-notification.h @@ -0,0 +1,67 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * gd-notification + * Based on gtk-notification from gnome-contacts: + * http://git.gnome.org/browse/gnome-contacts/tree/src/gtk-notification.c?id=3.3.91 + * + * Copyright (C) Erick Pérez Castellanos 2011 + * Copyright (C) 2012 Red Hat, Inc. + * + * This program is free software: you can redistribute 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see ."; + */ + +#ifndef _GD_NOTIFICATION_H_ +#define _GD_NOTIFICATION_H_ + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_NOTIFICATION (gd_notification_get_type ()) +#define GD_NOTIFICATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GD_TYPE_NOTIFICATION, GdNotification)) +#define GD_NOTIFICATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GD_TYPE_NOTIFICATION, GdNotificationClass)) +#define GTK_IS_NOTIFICATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GD_TYPE_NOTIFICATION)) +#define GTK_IS_NOTIFICATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GD_TYPE_NOTIFICATION)) +#define GD_NOTIFICATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GD_TYPE_NOTIFICATION, GdNotificationClass)) + +typedef struct _GdNotificationPrivate GdNotificationPrivate; +typedef struct _GdNotificationClass GdNotificationClass; +typedef struct _GdNotification GdNotification; + +struct _GdNotificationClass { + GtkBinClass parent_class; + + /* Signals */ + void (*dismissed) (GdNotification *self); +}; + +struct _GdNotification { + GtkBin parent_instance; + + /*< private > */ + GdNotificationPrivate *priv; +}; + +GType gd_notification_get_type (void) G_GNUC_CONST; + +GtkWidget *gd_notification_new (void); +void gd_notification_set_timeout (GdNotification *notification, + gint timeout_sec); +void gd_notification_dismiss (GdNotification *notification); +void gd_notification_set_show_close_button (GdNotification *notification, + gboolean show_close_button); + +G_END_DECLS + +#endif /* _GD_NOTIFICATION_H_ */ diff --git a/subprojects/libgd/libgd/gd-styled-text-renderer.c b/subprojects/libgd/libgd/gd-styled-text-renderer.c new file mode 100644 index 0000000..bdf72d2 --- /dev/null +++ b/subprojects/libgd/libgd/gd-styled-text-renderer.c @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-styled-text-renderer.h" + +typedef struct _GdStyledTextRendererPrivate GdStyledTextRendererPrivate; + +struct _GdStyledTextRendererPrivate { + GList *style_classes; +}; + +G_DEFINE_TYPE_WITH_PRIVATE (GdStyledTextRenderer, gd_styled_text_renderer, GTK_TYPE_CELL_RENDERER_TEXT) + +static void +gd_styled_text_renderer_render (GtkCellRenderer *cell, + cairo_t *cr, + GtkWidget *widget, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, + GtkCellRendererState flags) +{ + GdStyledTextRenderer *self = GD_STYLED_TEXT_RENDERER (cell); + GdStyledTextRendererPrivate *priv; + GtkStyleContext *context; + const gchar *style_class; + GList *l; + + priv = gd_styled_text_renderer_get_instance_private (self); + + context = gtk_widget_get_style_context (widget); + gtk_style_context_save (context); + + for (l = priv->style_classes; l != NULL; l = l->next) + { + style_class = l->data; + gtk_style_context_add_class (context, style_class); + } + + GTK_CELL_RENDERER_CLASS (gd_styled_text_renderer_parent_class)->render + (cell, cr, widget, + background_area, cell_area, flags); + + gtk_style_context_restore (context); +} + +static void +gd_styled_text_renderer_finalize (GObject *obj) +{ + GdStyledTextRenderer *self = GD_STYLED_TEXT_RENDERER (obj); + GdStyledTextRendererPrivate *priv; + + priv = gd_styled_text_renderer_get_instance_private (self); + + if (priv->style_classes != NULL) + { + g_list_free_full (priv->style_classes, g_free); + priv->style_classes = NULL; + } + + G_OBJECT_CLASS (gd_styled_text_renderer_parent_class)->finalize (obj); +} + +static void +gd_styled_text_renderer_class_init (GdStyledTextRendererClass *klass) +{ + GtkCellRendererClass *crclass = GTK_CELL_RENDERER_CLASS (klass); + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->finalize = gd_styled_text_renderer_finalize; + crclass->render = gd_styled_text_renderer_render; +} + +static void +gd_styled_text_renderer_init (GdStyledTextRenderer *self) +{ +} + +GtkCellRenderer * +gd_styled_text_renderer_new (void) +{ + return g_object_new (GD_TYPE_STYLED_TEXT_RENDERER, + NULL); +} + +void +gd_styled_text_renderer_add_class (GdStyledTextRenderer *self, + const gchar *class) +{ + GdStyledTextRendererPrivate *priv; + + priv = gd_styled_text_renderer_get_instance_private (self); + + if (g_list_find_custom (priv->style_classes, class, (GCompareFunc) g_strcmp0)) + return; + + priv->style_classes = g_list_append (priv->style_classes, g_strdup (class)); +} + +void +gd_styled_text_renderer_remove_class (GdStyledTextRenderer *self, + const gchar *class) +{ + GdStyledTextRendererPrivate *priv; + GList *class_element; + + priv = gd_styled_text_renderer_get_instance_private (self); + + class_element = g_list_find_custom (priv->style_classes, class, (GCompareFunc) g_strcmp0); + + if (class_element == NULL) + return; + + priv->style_classes = g_list_remove_link (priv->style_classes, class_element); + g_free (class_element->data); + g_list_free_1 (class_element); +} diff --git a/subprojects/libgd/libgd/gd-styled-text-renderer.h b/subprojects/libgd/libgd/gd-styled-text-renderer.h new file mode 100644 index 0000000..42f606b --- /dev/null +++ b/subprojects/libgd/libgd/gd-styled-text-renderer.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef _GD_STYLED_TEXT_RENDERER_H +#define _GD_STYLED_TEXT_RENDERER_H + +#include + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_STYLED_TEXT_RENDERER gd_styled_text_renderer_get_type() +G_DECLARE_DERIVABLE_TYPE (GdStyledTextRenderer, + gd_styled_text_renderer, + GD, + STYLED_TEXT_RENDERER, + GtkCellRendererText) + +struct _GdStyledTextRendererClass +{ + GtkCellRendererTextClass parent_class; +}; + +GtkCellRenderer *gd_styled_text_renderer_new (void); +void gd_styled_text_renderer_add_class (GdStyledTextRenderer *self, + const gchar *class); +void gd_styled_text_renderer_remove_class (GdStyledTextRenderer *self, + const gchar *class); + +G_END_DECLS + +#endif /* _GD_STYLED_TEXT_RENDERER_H */ diff --git a/subprojects/libgd/libgd/gd-tagged-entry.c b/subprojects/libgd/libgd/gd-tagged-entry.c new file mode 100644 index 0000000..5db139e --- /dev/null +++ b/subprojects/libgd/libgd/gd-tagged-entry.c @@ -0,0 +1,1240 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * Copyright (c) 2013 Ignacio Casal Quinteiro + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-tagged-entry.h" + +#include + +#define BUTTON_INTERNAL_SPACING 6 + +struct _GdTaggedEntryTagPrivate { + GdTaggedEntry *entry; + GdkWindow *window; + PangoLayout *layout; + + gchar *label; + gchar *style; + gboolean has_close_button; + + cairo_surface_t *close_surface; + GtkStateFlags last_button_state; +}; + +struct _GdTaggedEntryPrivate { + GList *tags; + + GdTaggedEntryTag *in_child; + gboolean in_child_button; + gboolean in_child_active; + gboolean in_child_button_active; + gboolean button_visible; +}; + +enum { + SIGNAL_TAG_CLICKED, + SIGNAL_TAG_BUTTON_CLICKED, + LAST_SIGNAL +}; + +enum { + PROP_0, + PROP_TAG_BUTTON_VISIBLE, + NUM_PROPERTIES +}; + +enum { + PROP_TAG_0, + PROP_TAG_LABEL, + PROP_TAG_HAS_CLOSE_BUTTON, + PROP_TAG_STYLE, + NUM_TAG_PROPERTIES +}; + +G_DEFINE_TYPE_WITH_PRIVATE (GdTaggedEntry, gd_tagged_entry, GTK_TYPE_SEARCH_ENTRY) +G_DEFINE_TYPE_WITH_PRIVATE (GdTaggedEntryTag, gd_tagged_entry_tag, G_TYPE_OBJECT) + +static guint signals[LAST_SIGNAL] = { 0, }; +static GParamSpec *properties[NUM_PROPERTIES] = { NULL, }; +static GParamSpec *tag_properties[NUM_TAG_PROPERTIES] = { NULL, }; + +static void gd_tagged_entry_get_text_area_size (GtkEntry *entry, + gint *x, + gint *y, + gint *width, + gint *height); +static gint gd_tagged_entry_tag_get_width (GdTaggedEntryTag *tag, + GdTaggedEntry *entry); +static GtkStyleContext * gd_tagged_entry_tag_get_context (GdTaggedEntryTag *tag, + GdTaggedEntry *entry); + +static void +gd_tagged_entry_tag_get_margin (GdTaggedEntryTag *tag, + GdTaggedEntry *entry, + GtkBorder *margin) +{ + GtkStyleContext *context; + + context = gd_tagged_entry_tag_get_context (tag, entry); + gtk_style_context_set_state (context, GTK_STATE_FLAG_NORMAL); + gtk_style_context_get_margin (context, + gtk_style_context_get_state (context), + margin); + gtk_style_context_restore (context); +} + +static void +gd_tagged_entry_tag_ensure_close_surface (GdTaggedEntryTag *tag, + GtkStyleContext *context) +{ + GtkIconInfo *info; + GdkPixbuf *pixbuf; + gint icon_size; + gint scale_factor; + + if (tag->priv->close_surface != NULL) + return; + + gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, + &icon_size, NULL); + scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (tag->priv->entry)); + + info = gtk_icon_theme_lookup_icon_for_scale (gtk_icon_theme_get_default (), + "window-close-symbolic", + icon_size, scale_factor, + GTK_ICON_LOOKUP_GENERIC_FALLBACK); + + /* FIXME: we need a fallback icon in case the icon is not found */ + pixbuf = gtk_icon_info_load_symbolic_for_context (info, context, NULL, NULL); + tag->priv->close_surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale_factor, tag->priv->window); + + g_object_unref (info); + g_object_unref (pixbuf); +} + +static gint +gd_tagged_entry_tag_panel_get_height (GdTaggedEntryTag *tag, + GdTaggedEntry *entry) +{ + GtkWidget *widget = GTK_WIDGET (entry); + gint height, req_height; + GtkRequisition requisition; + GtkAllocation allocation; + GtkBorder margin; + + gtk_widget_get_allocation (widget, &allocation); + gtk_widget_get_preferred_size (widget, &requisition, NULL); + gd_tagged_entry_tag_get_margin (tag, entry, &margin); + + /* the tag panel height is the whole entry height, minus the tag margins */ + req_height = requisition.height - gtk_widget_get_margin_top (widget) - gtk_widget_get_margin_bottom (widget); + height = MIN (req_height, allocation.height) - margin.top - margin.bottom; + + return height; +} + +static void +gd_tagged_entry_tag_panel_get_position (GdTaggedEntry *self, + gint *x_out, + gint *y_out) +{ + GtkWidget *widget = GTK_WIDGET (self); + gint text_x, text_y, text_width, text_height, req_height; + GtkAllocation allocation; + GtkRequisition requisition; + + gtk_widget_get_allocation (widget, &allocation); + gtk_widget_get_preferred_size (widget, &requisition, NULL); + req_height = requisition.height - gtk_widget_get_margin_top (widget) - gtk_widget_get_margin_bottom (widget); + + gd_tagged_entry_get_text_area_size (GTK_ENTRY (self), &text_x, &text_y, &text_width, &text_height); + + /* allocate the panel immediately after the text area */ + if (x_out) + *x_out = allocation.x + text_x + text_width; + if (y_out) + *y_out = allocation.y + (gint) floor ((allocation.height - req_height) / 2); +} + +static gint +gd_tagged_entry_tag_panel_get_width (GdTaggedEntry *self) +{ + GdTaggedEntryTag *tag; + gint width; + GList *l; + + width = 0; + + for (l = self->priv->tags; l != NULL; l = l->next) + { + tag = l->data; + width += gd_tagged_entry_tag_get_width (tag, self); + } + + return width; +} + +static void +gd_tagged_entry_tag_ensure_layout (GdTaggedEntryTag *tag, + GdTaggedEntry *entry) +{ + if (tag->priv->layout != NULL) + return; + + tag->priv->layout = pango_layout_new (gtk_widget_get_pango_context (GTK_WIDGET (entry))); + pango_layout_set_text (tag->priv->layout, tag->priv->label, -1); +} + +static GtkStateFlags +gd_tagged_entry_tag_get_state (GdTaggedEntryTag *tag, + GdTaggedEntry *entry) +{ + GtkStateFlags state = GTK_STATE_FLAG_NORMAL; + + if (entry->priv->in_child == tag) + state |= GTK_STATE_FLAG_PRELIGHT; + + if (entry->priv->in_child_active) + state |= GTK_STATE_FLAG_ACTIVE; + + return state; +} + +static GtkStateFlags +gd_tagged_entry_tag_get_button_state (GdTaggedEntryTag *tag, + GdTaggedEntry *entry) +{ + GtkStateFlags state = GTK_STATE_FLAG_NORMAL; + + if (entry->priv->in_child == tag) + { + if (entry->priv->in_child_button_active) + state |= GTK_STATE_FLAG_ACTIVE; + + else if (entry->priv->in_child_button) + state |= GTK_STATE_FLAG_PRELIGHT; + } + + return state; +} + +static GtkStyleContext * +gd_tagged_entry_tag_get_context (GdTaggedEntryTag *tag, + GdTaggedEntry *entry) +{ + GtkWidget *widget = GTK_WIDGET (entry); + GtkStyleContext *retval; + GList *l, *list; + + retval = gtk_widget_get_style_context (widget); + gtk_style_context_save (retval); + + list = gtk_style_context_list_classes (retval); + for (l = list; l; l = l->next) + gtk_style_context_remove_class (retval, l->data); + g_list_free (list); + gtk_style_context_add_class (retval, tag->priv->style); + + return retval; +} + +static gint +gd_tagged_entry_tag_get_width (GdTaggedEntryTag *tag, + GdTaggedEntry *entry) +{ + GtkBorder button_padding, button_border, button_margin; + GtkStyleContext *context; + GtkStateFlags state; + gint layout_width; + gint button_width; + gint scale_factor; + + gd_tagged_entry_tag_ensure_layout (tag, entry); + pango_layout_get_pixel_size (tag->priv->layout, &layout_width, NULL); + + context = gd_tagged_entry_tag_get_context (tag, entry); + state = gd_tagged_entry_tag_get_state (tag, entry); + + gtk_style_context_set_state (context, state); + gtk_style_context_get_padding (context, + gtk_style_context_get_state (context), + &button_padding); + gtk_style_context_get_border (context, + gtk_style_context_get_state (context), + &button_border); + gtk_style_context_get_margin (context, + gtk_style_context_get_state (context), + &button_margin); + + gd_tagged_entry_tag_ensure_close_surface (tag, context); + + gtk_style_context_restore (context); + + button_width = 0; + if (entry->priv->button_visible && tag->priv->has_close_button) + { + scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (entry)); + button_width = cairo_image_surface_get_width (tag->priv->close_surface) / scale_factor + + BUTTON_INTERNAL_SPACING; + } + + return layout_width + button_padding.left + button_padding.right + + button_border.left + button_border.right + + button_margin.left + button_margin.right + + button_width; +} + +static void +gd_tagged_entry_tag_get_size (GdTaggedEntryTag *tag, + GdTaggedEntry *entry, + gint *width_out, + gint *height_out) +{ + gint width, panel_height; + + width = gd_tagged_entry_tag_get_width (tag, entry); + panel_height = gd_tagged_entry_tag_panel_get_height (tag, entry); + + if (width_out) + *width_out = width; + if (height_out) + *height_out = panel_height; +} + +static void +gd_tagged_entry_tag_get_relative_allocations (GdTaggedEntryTag *tag, + GdTaggedEntry *entry, + GtkStyleContext *context, + GtkAllocation *background_allocation_out, + GtkAllocation *layout_allocation_out, + GtkAllocation *button_allocation_out) +{ + GtkAllocation background_allocation, layout_allocation, button_allocation; + gint width, height, x, y, pix_width, pix_height; + gint layout_width, layout_height; + gint scale_factor; + GtkBorder padding, border; + GtkStateFlags state; + + width = gdk_window_get_width (tag->priv->window); + height = gdk_window_get_height (tag->priv->window); + scale_factor = gdk_window_get_scale_factor (tag->priv->window); + + state = gd_tagged_entry_tag_get_state (tag, entry); + gtk_style_context_save (context); + gtk_style_context_set_state (context, state); + gtk_style_context_get_margin (context, + gtk_style_context_get_state (context), + &padding); + gtk_style_context_restore (context); + + width -= padding.left + padding.right; + height -= padding.top + padding.bottom; + x = padding.left; + y = padding.top; + + background_allocation.x = x; + background_allocation.y = y; + background_allocation.width = width; + background_allocation.height = height; + + layout_allocation = button_allocation = background_allocation; + + gtk_style_context_save (context); + gtk_style_context_set_state (context, state); + gtk_style_context_get_padding (context, + gtk_style_context_get_state (context), + &padding); + gtk_style_context_get_border (context, + gtk_style_context_get_state (context), + &border); + gtk_style_context_restore (context); + + gd_tagged_entry_tag_ensure_layout (tag, entry); + pango_layout_get_pixel_size (tag->priv->layout, &layout_width, &layout_height); + + layout_allocation.x += border.left + padding.left; + layout_allocation.y += (layout_allocation.height - layout_height) / 2; + + if (entry->priv->button_visible && tag->priv->has_close_button) + { + pix_width = cairo_image_surface_get_width (tag->priv->close_surface) / scale_factor; + pix_height = cairo_image_surface_get_height (tag->priv->close_surface) / scale_factor; + } + else + { + pix_width = 0; + pix_height = 0; + } + + button_allocation.x += width - pix_width - border.right - padding.right; + button_allocation.y += (height - pix_height) / 2; + button_allocation.width = pix_width; + button_allocation.height = pix_height; + + if (background_allocation_out) + *background_allocation_out = background_allocation; + if (layout_allocation_out) + *layout_allocation_out = layout_allocation; + if (button_allocation_out) + *button_allocation_out = button_allocation; +} + +static gboolean +gd_tagged_entry_tag_event_is_button (GdTaggedEntryTag *tag, + GdTaggedEntry *entry, + gdouble event_x, + gdouble event_y) +{ + GtkAllocation button_allocation; + GtkStyleContext *context; + + if (!entry->priv->button_visible || !tag->priv->has_close_button) + return FALSE; + + context = gd_tagged_entry_tag_get_context (tag, entry); + gd_tagged_entry_tag_get_relative_allocations (tag, entry, context, NULL, NULL, &button_allocation); + + gtk_style_context_restore (context); + + /* see if the event falls into the button allocation */ + if ((event_x >= button_allocation.x && + event_x <= button_allocation.x + button_allocation.width) && + (event_y >= button_allocation.y && + event_y <= button_allocation.y + button_allocation.height)) + return TRUE; + + return FALSE; +} + +gboolean +gd_tagged_entry_tag_get_area (GdTaggedEntryTag *tag, + cairo_rectangle_int_t *rect) +{ + GtkStyleContext *context; + GtkAllocation background_allocation; + int window_x, window_y; + GtkAllocation alloc; + + g_return_val_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag), FALSE); + g_return_val_if_fail (rect != NULL, FALSE); + + gdk_window_get_position (tag->priv->window, &window_x, &window_y); + gtk_widget_get_allocation (GTK_WIDGET (tag->priv->entry), &alloc); + context = gd_tagged_entry_tag_get_context (tag, tag->priv->entry); + gd_tagged_entry_tag_get_relative_allocations (tag, tag->priv->entry, context, + &background_allocation, + NULL, NULL); + gtk_style_context_restore (context); + + rect->x = window_x - alloc.x + background_allocation.x; + rect->y = window_y - alloc.y + background_allocation.y; + rect->width = background_allocation.width; + rect->height = background_allocation.height; + + return TRUE; +} + +static void +gd_tagged_entry_tag_draw (GdTaggedEntryTag *tag, + cairo_t *cr, + GdTaggedEntry *entry) +{ + GtkStyleContext *context; + GtkStateFlags state; + GtkAllocation background_allocation, layout_allocation, button_allocation; + + context = gd_tagged_entry_tag_get_context (tag, entry); + gd_tagged_entry_tag_get_relative_allocations (tag, entry, context, + &background_allocation, + &layout_allocation, + &button_allocation); + + cairo_save (cr); + gtk_cairo_transform_to_window (cr, GTK_WIDGET (entry), tag->priv->window); + + gtk_style_context_save (context); + + state = gd_tagged_entry_tag_get_state (tag, entry); + gtk_style_context_set_state (context, state); + gtk_render_background (context, cr, + background_allocation.x, background_allocation.y, + background_allocation.width, background_allocation.height); + gtk_render_frame (context, cr, + background_allocation.x, background_allocation.y, + background_allocation.width, background_allocation.height); + + gtk_render_layout (context, cr, + layout_allocation.x, layout_allocation.y, + tag->priv->layout); + + gtk_style_context_restore (context); + + if (!entry->priv->button_visible || !tag->priv->has_close_button) + goto done; + + gtk_style_context_add_class (context, GTK_STYLE_CLASS_BUTTON); + state = gd_tagged_entry_tag_get_button_state (tag, entry); + gtk_style_context_set_state (context, state); + + /* if the state changed since last time we draw the pixbuf, + * clear and redraw it. + */ + if (state != tag->priv->last_button_state) + { + g_clear_pointer (&tag->priv->close_surface, cairo_surface_destroy); + gd_tagged_entry_tag_ensure_close_surface (tag, context); + + tag->priv->last_button_state = state; + } + + gtk_render_background (context, cr, + button_allocation.x, button_allocation.y, + button_allocation.width, button_allocation.height); + gtk_render_frame (context, cr, + button_allocation.x, button_allocation.y, + button_allocation.width, button_allocation.height); + + gtk_render_icon_surface (context, cr, + tag->priv->close_surface, + button_allocation.x, button_allocation.y); + +done: + gtk_style_context_restore (context); + + cairo_restore (cr); +} + +static void +gd_tagged_entry_tag_unrealize (GdTaggedEntryTag *tag) +{ + if (tag->priv->window == NULL) + return; + + gdk_window_set_user_data (tag->priv->window, NULL); + gdk_window_destroy (tag->priv->window); + tag->priv->window = NULL; +} + +static void +gd_tagged_entry_tag_realize (GdTaggedEntryTag *tag, + GdTaggedEntry *entry) +{ + GtkWidget *widget = GTK_WIDGET (entry); + GdkWindowAttr attributes; + gint attributes_mask; + gint tag_width, tag_height; + + if (tag->priv->window != NULL) + return; + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.wclass = GDK_INPUT_ONLY; + attributes.event_mask = gtk_widget_get_events (widget); + attributes.event_mask |= GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK + | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK; + + gd_tagged_entry_tag_get_size (tag, entry, &tag_width, &tag_height); + attributes.x = 0; + attributes.y = 0; + attributes.width = tag_width; + attributes.height = tag_height; + + attributes_mask = GDK_WA_X | GDK_WA_Y; + + tag->priv->window = gdk_window_new (gtk_widget_get_window (widget), + &attributes, attributes_mask); + gdk_window_set_user_data (tag->priv->window, widget); +} + +static gboolean +gd_tagged_entry_draw (GtkWidget *widget, + cairo_t *cr) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + GList *l; + + GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->draw (widget, cr); + + for (l = self->priv->tags; l != NULL; l = l->next) + { + tag = l->data; + gd_tagged_entry_tag_draw (tag, cr, self); + } + + return FALSE; +} + +static void +gd_tagged_entry_map (GtkWidget *widget) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + GList *l; + + if (gtk_widget_get_realized (widget) && !gtk_widget_get_mapped (widget)) + { + GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->map (widget); + + for (l = self->priv->tags; l != NULL; l = l->next) + { + tag = l->data; + gdk_window_show (tag->priv->window); + } + } +} + +static void +gd_tagged_entry_unmap (GtkWidget *widget) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + GList *l; + + if (gtk_widget_get_mapped (widget)) + { + for (l = self->priv->tags; l != NULL; l = l->next) + { + tag = l->data; + gdk_window_hide (tag->priv->window); + } + + GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->unmap (widget); + } +} + +static void +gd_tagged_entry_realize (GtkWidget *widget) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + GList *l; + + GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->realize (widget); + + for (l = self->priv->tags; l != NULL; l = l->next) + { + tag = l->data; + gd_tagged_entry_tag_realize (tag, self); + } +} + +static void +gd_tagged_entry_unrealize (GtkWidget *widget) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + GList *l; + + GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->unrealize (widget); + + for (l = self->priv->tags; l != NULL; l = l->next) + { + tag = l->data; + gd_tagged_entry_tag_unrealize (tag); + } +} + +static void +gd_tagged_entry_get_text_area_size (GtkEntry *entry, + gint *x, + gint *y, + gint *width, + gint *height) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (entry); + gint tag_panel_width; + + GTK_ENTRY_CLASS (gd_tagged_entry_parent_class)->get_text_area_size (entry, x, y, width, height); + + tag_panel_width = gd_tagged_entry_tag_panel_get_width (self); + + if (width) + *width -= tag_panel_width; +} + +static void +gd_tagged_entry_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + gint x, y, width, height; + GdTaggedEntryTag *tag; + GList *l; + + gtk_widget_set_allocation (widget, allocation); + GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->size_allocate (widget, allocation); + + if (gtk_widget_get_realized (widget)) + { + gd_tagged_entry_tag_panel_get_position (self, &x, &y); + + for (l = self->priv->tags; l != NULL; l = l->next) + { + GtkBorder margin; + + tag = l->data; + gd_tagged_entry_tag_get_size (tag, self, &width, &height); + gd_tagged_entry_tag_get_margin (tag, self, &margin); + gdk_window_move_resize (tag->priv->window, x, y + margin.top, width, height); + + x += width; + } + + gtk_widget_queue_draw (widget); + } +} + +static void +gd_tagged_entry_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + gint tag_panel_width; + + GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->get_preferred_width (widget, minimum, natural); + + tag_panel_width = gd_tagged_entry_tag_panel_get_width (self); + + if (minimum) + *minimum += tag_panel_width; + if (natural) + *natural += tag_panel_width; +} + +static void +gd_tagged_entry_finalize (GObject *obj) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (obj); + + if (self->priv->tags != NULL) + { + g_list_free_full (self->priv->tags, g_object_unref); + self->priv->tags = NULL; + } + + G_OBJECT_CLASS (gd_tagged_entry_parent_class)->finalize (obj); +} + +static GdTaggedEntryTag * +gd_tagged_entry_find_tag_by_window (GdTaggedEntry *self, + GdkWindow *window) +{ + GdTaggedEntryTag *tag = NULL, *elem; + GList *l; + + for (l = self->priv->tags; l != NULL; l = l->next) + { + elem = l->data; + if (elem->priv->window == window) + { + tag = elem; + break; + } + } + + return tag; +} + +static gint +gd_tagged_entry_enter_notify (GtkWidget *widget, + GdkEventCrossing *event) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + + tag = gd_tagged_entry_find_tag_by_window (self, event->window); + + if (tag != NULL) + { + self->priv->in_child = tag; + gtk_widget_queue_draw (widget); + } + + return GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->enter_notify_event (widget, event); +} + +static gint +gd_tagged_entry_leave_notify (GtkWidget *widget, + GdkEventCrossing *event) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + + if (self->priv->in_child != NULL) + { + self->priv->in_child = NULL; + gtk_widget_queue_draw (widget); + } + + return GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->leave_notify_event (widget, event); +} + +static gint +gd_tagged_entry_motion_notify (GtkWidget *widget, + GdkEventMotion *event) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + + tag = gd_tagged_entry_find_tag_by_window (self, event->window); + + if (tag != NULL) + { + gdk_event_request_motions (event); + + self->priv->in_child = tag; + self->priv->in_child_button = gd_tagged_entry_tag_event_is_button (tag, self, event->x, event->y); + gtk_widget_queue_draw (widget); + + return FALSE; + } + + return GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->motion_notify_event (widget, event); +} + +static gboolean +gd_tagged_entry_button_release_event (GtkWidget *widget, + GdkEventButton *event) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + + tag = gd_tagged_entry_find_tag_by_window (self, event->window); + + if (tag != NULL) + { + self->priv->in_child_active = FALSE; + + if (gd_tagged_entry_tag_event_is_button (tag, self, event->x, event->y)) + { + self->priv->in_child_button_active = FALSE; + g_signal_emit (self, signals[SIGNAL_TAG_BUTTON_CLICKED], 0, tag); + } + else + { + g_signal_emit (self, signals[SIGNAL_TAG_CLICKED], 0, tag); + } + + gtk_widget_queue_draw (widget); + + return TRUE; + } + + return GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->button_release_event (widget, event); +} + +static gboolean +gd_tagged_entry_button_press_event (GtkWidget *widget, + GdkEventButton *event) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (widget); + GdTaggedEntryTag *tag; + + tag = gd_tagged_entry_find_tag_by_window (self, event->window); + + if (tag != NULL) + { + if (gd_tagged_entry_tag_event_is_button (tag, self, event->x, event->y)) + self->priv->in_child_button_active = TRUE; + else + self->priv->in_child_active = TRUE; + + gtk_widget_queue_draw (widget); + + return TRUE; + } + + return GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->button_press_event (widget, event); +} + +static void +gd_tagged_entry_init (GdTaggedEntry *self) +{ + self->priv = gd_tagged_entry_get_instance_private (self); + self->priv->button_visible = TRUE; +} + +static void +gd_tagged_entry_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (object); + + switch (property_id) + { + case PROP_TAG_BUTTON_VISIBLE: + g_value_set_boolean (value, gd_tagged_entry_get_tag_button_visible (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gd_tagged_entry_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GdTaggedEntry *self = GD_TAGGED_ENTRY (object); + + switch (property_id) + { + case PROP_TAG_BUTTON_VISIBLE: + gd_tagged_entry_set_tag_button_visible (self, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gd_tagged_entry_class_init (GdTaggedEntryClass *klass) +{ + GtkWidgetClass *wclass = GTK_WIDGET_CLASS (klass); + GtkEntryClass *eclass = GTK_ENTRY_CLASS (klass); + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->finalize = gd_tagged_entry_finalize; + oclass->set_property = gd_tagged_entry_set_property; + oclass->get_property = gd_tagged_entry_get_property; + + wclass->realize = gd_tagged_entry_realize; + wclass->unrealize = gd_tagged_entry_unrealize; + wclass->map = gd_tagged_entry_map; + wclass->unmap = gd_tagged_entry_unmap; + wclass->size_allocate = gd_tagged_entry_size_allocate; + wclass->get_preferred_width = gd_tagged_entry_get_preferred_width; + wclass->draw = gd_tagged_entry_draw; + wclass->enter_notify_event = gd_tagged_entry_enter_notify; + wclass->leave_notify_event = gd_tagged_entry_leave_notify; + wclass->motion_notify_event = gd_tagged_entry_motion_notify; + wclass->button_press_event = gd_tagged_entry_button_press_event; + wclass->button_release_event = gd_tagged_entry_button_release_event; + + eclass->get_text_area_size = gd_tagged_entry_get_text_area_size; + + signals[SIGNAL_TAG_CLICKED] = + g_signal_new ("tag-clicked", + GD_TYPE_TAGGED_ENTRY, + G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED, + 0, NULL, NULL, NULL, + G_TYPE_NONE, + 1, GD_TYPE_TAGGED_ENTRY_TAG); + signals[SIGNAL_TAG_BUTTON_CLICKED] = + g_signal_new ("tag-button-clicked", + GD_TYPE_TAGGED_ENTRY, + G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED, + 0, NULL, NULL, NULL, + G_TYPE_NONE, + 1, GD_TYPE_TAGGED_ENTRY_TAG); + + properties[PROP_TAG_BUTTON_VISIBLE] = + g_param_spec_boolean ("tag-close-visible", "Tag close icon visibility", + "Whether the close button should be shown in tags.", TRUE, + G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, NUM_PROPERTIES, properties); +} + +static void +gd_tagged_entry_tag_init (GdTaggedEntryTag *self) +{ + GdTaggedEntryTagPrivate *priv; + + self->priv = gd_tagged_entry_tag_get_instance_private (self); + priv = self->priv; + + priv->last_button_state = GTK_STATE_FLAG_NORMAL; +} + +static void +gd_tagged_entry_tag_finalize (GObject *obj) +{ + GdTaggedEntryTag *tag = GD_TAGGED_ENTRY_TAG (obj); + GdTaggedEntryTagPrivate *priv = tag->priv; + + if (priv->window != NULL) + gd_tagged_entry_tag_unrealize (tag); + + g_clear_object (&priv->layout); + g_clear_pointer (&priv->close_surface, cairo_surface_destroy); + g_free (priv->label); + g_free (priv->style); + + G_OBJECT_CLASS (gd_tagged_entry_tag_parent_class)->finalize (obj); +} + +static void +gd_tagged_entry_tag_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GdTaggedEntryTag *self = GD_TAGGED_ENTRY_TAG (object); + + switch (property_id) + { + case PROP_TAG_LABEL: + g_value_set_string (value, gd_tagged_entry_tag_get_label (self)); + break; + case PROP_TAG_HAS_CLOSE_BUTTON: + g_value_set_boolean (value, gd_tagged_entry_tag_get_has_close_button (self)); + break; + case PROP_TAG_STYLE: + g_value_set_string (value, gd_tagged_entry_tag_get_style (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gd_tagged_entry_tag_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GdTaggedEntryTag *self = GD_TAGGED_ENTRY_TAG (object); + + switch (property_id) + { + case PROP_TAG_LABEL: + gd_tagged_entry_tag_set_label (self, g_value_get_string (value)); + break; + case PROP_TAG_HAS_CLOSE_BUTTON: + gd_tagged_entry_tag_set_has_close_button (self, g_value_get_boolean (value)); + break; + case PROP_TAG_STYLE: + gd_tagged_entry_tag_set_style (self, g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gd_tagged_entry_tag_class_init (GdTaggedEntryTagClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->finalize = gd_tagged_entry_tag_finalize; + oclass->set_property = gd_tagged_entry_tag_set_property; + oclass->get_property = gd_tagged_entry_tag_get_property; + + tag_properties[PROP_TAG_LABEL] = + g_param_spec_string ("label", "Label", + "Text to show on the tag.", NULL, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + tag_properties[PROP_TAG_HAS_CLOSE_BUTTON] = + g_param_spec_boolean ("has-close-button", "Tag has a close button", + "Whether the tag has a close button.", TRUE, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + tag_properties[PROP_TAG_STYLE] = + g_param_spec_string ("style", "Style", + "Style of the tag.", "entry-tag", + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, NUM_TAG_PROPERTIES, tag_properties); +} + +GdTaggedEntry * +gd_tagged_entry_new (void) +{ + return g_object_new (GD_TYPE_TAGGED_ENTRY, NULL); +} + +gboolean +gd_tagged_entry_insert_tag (GdTaggedEntry *self, + GdTaggedEntryTag *tag, + gint position) +{ + if (g_list_find (self->priv->tags, tag) != NULL) + return FALSE; + + tag->priv->entry = self; + + self->priv->tags = g_list_insert (self->priv->tags, g_object_ref (tag), position); + + if (gtk_widget_get_realized (GTK_WIDGET (self))) + gd_tagged_entry_tag_realize (tag, self); + + if (gtk_widget_get_mapped (GTK_WIDGET (self))) + gdk_window_show_unraised (tag->priv->window); + + gtk_widget_queue_resize (GTK_WIDGET (self)); + + return TRUE; +} + +gboolean +gd_tagged_entry_add_tag (GdTaggedEntry *self, + GdTaggedEntryTag *tag) +{ + return gd_tagged_entry_insert_tag (self, tag, -1); +} + +gboolean +gd_tagged_entry_remove_tag (GdTaggedEntry *self, + GdTaggedEntryTag *tag) +{ + if (!g_list_find (self->priv->tags, tag)) + return FALSE; + + gd_tagged_entry_tag_unrealize (tag); + + self->priv->tags = g_list_remove (self->priv->tags, tag); + g_object_unref (tag); + + gtk_widget_queue_resize (GTK_WIDGET (self)); + + return TRUE; +} + +GdTaggedEntryTag * +gd_tagged_entry_tag_new (const gchar *label) +{ + return g_object_new (GD_TYPE_TAGGED_ENTRY_TAG, "label", label, NULL); +} + +void +gd_tagged_entry_tag_set_label (GdTaggedEntryTag *tag, + const gchar *label) +{ + GdTaggedEntryTagPrivate *priv; + + g_return_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag)); + + priv = tag->priv; + + if (g_strcmp0 (priv->label, label) != 0) + { + GtkWidget *entry; + + g_free (priv->label); + priv->label = g_strdup (label); + g_clear_object (&priv->layout); + + entry = GTK_WIDGET (tag->priv->entry); + if (entry) + gtk_widget_queue_resize (entry); + } +} + +const gchar * +gd_tagged_entry_tag_get_label (GdTaggedEntryTag *tag) +{ + g_return_val_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag), NULL); + + return tag->priv->label; +} + +void +gd_tagged_entry_tag_set_has_close_button (GdTaggedEntryTag *tag, + gboolean has_close_button) +{ + GdTaggedEntryTagPrivate *priv; + + g_return_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag)); + + priv = tag->priv; + + has_close_button = has_close_button != FALSE; + if (priv->has_close_button != has_close_button) + { + GtkWidget *entry; + + priv->has_close_button = has_close_button; + g_clear_object (&priv->layout); + + entry = GTK_WIDGET (priv->entry); + if (entry) + gtk_widget_queue_resize (entry); + } +} + +gboolean +gd_tagged_entry_tag_get_has_close_button (GdTaggedEntryTag *tag) +{ + g_return_val_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag), FALSE); + + return tag->priv->has_close_button; +} + +void +gd_tagged_entry_tag_set_style (GdTaggedEntryTag *tag, + const gchar *style) +{ + GdTaggedEntryTagPrivate *priv; + + g_return_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag)); + + priv = tag->priv; + + if (g_strcmp0 (priv->style, style) != 0) + { + GtkWidget *entry; + + g_free (priv->style); + priv->style = g_strdup (style); + g_clear_object (&priv->layout); + + entry = GTK_WIDGET (tag->priv->entry); + if (entry) + gtk_widget_queue_resize (entry); + } +} + +const gchar * +gd_tagged_entry_tag_get_style (GdTaggedEntryTag *tag) +{ + g_return_val_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag), NULL); + + return tag->priv->style; +} + +void +gd_tagged_entry_set_tag_button_visible (GdTaggedEntry *self, + gboolean visible) +{ + g_return_if_fail (GD_IS_TAGGED_ENTRY (self)); + + if (self->priv->button_visible == visible) + return; + + self->priv->button_visible = visible; + gtk_widget_queue_resize (GTK_WIDGET (self)); + + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TAG_BUTTON_VISIBLE]); +} + +gboolean +gd_tagged_entry_get_tag_button_visible (GdTaggedEntry *self) +{ + g_return_val_if_fail (GD_IS_TAGGED_ENTRY (self), FALSE); + + return self->priv->button_visible; +} diff --git a/subprojects/libgd/libgd/gd-tagged-entry.h b/subprojects/libgd/libgd/gd-tagged-entry.h new file mode 100644 index 0000000..ba9f673 --- /dev/null +++ b/subprojects/libgd/libgd/gd-tagged-entry.h @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * Copyright (c) 2013 Ignacio Casal Quinteiro + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef __GD_TAGGED_ENTRY_H__ +#define __GD_TAGGED_ENTRY_H__ + +#include + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_TAGGED_ENTRY gd_tagged_entry_get_type() +#define GD_TAGGED_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GD_TYPE_TAGGED_ENTRY, GdTaggedEntry)) +#define GD_TAGGED_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GD_TYPE_TAGGED_ENTRY, GdTaggedEntryClass)) +#define GD_IS_TAGGED_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GD_TYPE_TAGGED_ENTRY)) +#define GD_IS_TAGGED_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GD_TYPE_TAGGED_ENTRY)) +#define GD_TAGGED_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GD_TYPE_TAGGED_ENTRY, GdTaggedEntryClass)) + +typedef struct _GdTaggedEntry GdTaggedEntry; +typedef struct _GdTaggedEntryClass GdTaggedEntryClass; +typedef struct _GdTaggedEntryPrivate GdTaggedEntryPrivate; + +typedef struct _GdTaggedEntryTag GdTaggedEntryTag; +typedef struct _GdTaggedEntryTagClass GdTaggedEntryTagClass; +typedef struct _GdTaggedEntryTagPrivate GdTaggedEntryTagPrivate; + +struct _GdTaggedEntry +{ + GtkSearchEntry parent; + + GdTaggedEntryPrivate *priv; +}; + +struct _GdTaggedEntryClass +{ + GtkSearchEntryClass parent_class; +}; + +#define GD_TYPE_TAGGED_ENTRY_TAG gd_tagged_entry_tag_get_type() +#define GD_TAGGED_ENTRY_TAG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GD_TYPE_TAGGED_ENTRY_TAG, GdTaggedEntryTag)) +#define GD_TAGGED_ENTRY_TAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GD_TYPE_TAGGED_ENTRY_TAG, GdTaggedEntryTagClass)) +#define GD_IS_TAGGED_ENTRY_TAG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GD_TYPE_TAGGED_ENTRY_TAG)) +#define GD_IS_TAGGED_ENTRY_TAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GD_TYPE_TAGGED_ENTRY_TAG)) +#define GD_TAGGED_ENTRY_TAG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GD_TYPE_TAGGED_ENTRY_TAG, GdTaggedEntryTagClass)) + +struct _GdTaggedEntryTag +{ + GObject parent; + + GdTaggedEntryTagPrivate *priv; +}; + +struct _GdTaggedEntryTagClass +{ + GObjectClass parent_class; +}; + +GType gd_tagged_entry_get_type (void) G_GNUC_CONST; + +GdTaggedEntry *gd_tagged_entry_new (void); + +void gd_tagged_entry_set_tag_button_visible (GdTaggedEntry *self, + gboolean visible); +gboolean gd_tagged_entry_get_tag_button_visible (GdTaggedEntry *self); + +gboolean gd_tagged_entry_insert_tag (GdTaggedEntry *self, + GdTaggedEntryTag *tag, + gint position); + +gboolean gd_tagged_entry_add_tag (GdTaggedEntry *self, + GdTaggedEntryTag *tag); + +gboolean gd_tagged_entry_remove_tag (GdTaggedEntry *self, + GdTaggedEntryTag *tag); + +GType gd_tagged_entry_tag_get_type (void) G_GNUC_CONST; + +GdTaggedEntryTag *gd_tagged_entry_tag_new (const gchar *label); + +void gd_tagged_entry_tag_set_label (GdTaggedEntryTag *tag, + const gchar *label); +const gchar *gd_tagged_entry_tag_get_label (GdTaggedEntryTag *tag); + +void gd_tagged_entry_tag_set_has_close_button (GdTaggedEntryTag *tag, + gboolean has_close_button); +gboolean gd_tagged_entry_tag_get_has_close_button (GdTaggedEntryTag *tag); + +void gd_tagged_entry_tag_set_style (GdTaggedEntryTag *tag, + const gchar *style); +const gchar *gd_tagged_entry_tag_get_style (GdTaggedEntryTag *tag); + +gboolean gd_tagged_entry_tag_get_area (GdTaggedEntryTag *tag, + cairo_rectangle_int_t *rect); + +G_END_DECLS + +#endif /* __GD_TAGGED_ENTRY_H__ */ diff --git a/subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.c b/subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.c new file mode 100644 index 0000000..069050b --- /dev/null +++ b/subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.c @@ -0,0 +1,280 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-toggle-pixbuf-renderer.h" + +enum { + PROP_ACTIVE = 1, + PROP_TOGGLE_VISIBLE, + PROP_PULSE, + NUM_PROPERTIES +}; + +static GParamSpec *properties[NUM_PROPERTIES] = { NULL, }; + +typedef struct _GdTogglePixbufRendererPrivate GdTogglePixbufRendererPrivate; + +struct _GdTogglePixbufRendererPrivate { + gboolean active; + gboolean toggle_visible; + + guint pulse; +}; + +G_DEFINE_TYPE_WITH_PRIVATE (GdTogglePixbufRenderer, gd_toggle_pixbuf_renderer, GTK_TYPE_CELL_RENDERER_PIXBUF) + +static void +render_check (GdTogglePixbufRenderer *self, + cairo_t *cr, + GtkWidget *widget, + const GdkRectangle *cell_area, + gint icon_size, + gint xpad, + gint ypad) +{ + GdTogglePixbufRendererPrivate *priv; + GtkStyleContext *context; + gint check_x, check_y, x_offset; + GtkTextDirection direction; + + priv = gd_toggle_pixbuf_renderer_get_instance_private (self); + context = gtk_widget_get_style_context (widget); + + if (!priv->toggle_visible) + return; + + direction = gtk_widget_get_direction (widget); + if (direction == GTK_TEXT_DIR_RTL) + x_offset = xpad; + else + x_offset = cell_area->width - icon_size - xpad; + + check_x = cell_area->x + x_offset; + check_y = cell_area->y + cell_area->height - icon_size - ypad; + + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_CHECK); + + if (priv->active) + gtk_style_context_set_state (context, gtk_widget_get_state_flags (widget) | GTK_STATE_FLAG_CHECKED); + + gtk_render_background (context, cr, + check_x, check_y, + icon_size, icon_size); + gtk_render_frame (context, cr, + check_x, check_y, + icon_size, icon_size); + gtk_render_check (context, cr, + check_x, check_y, + icon_size, icon_size); + gtk_style_context_restore (context); +} + +static void +render_activity (GdTogglePixbufRenderer *self, + cairo_t *cr, + GtkWidget *widget, + const GdkRectangle *cell_area, + gint icon_size, + gint xpad, + gint ypad) +{ + GdTogglePixbufRendererPrivate *priv; + gint x, y, width, height; + + priv = gd_toggle_pixbuf_renderer_get_instance_private (self); + + if (priv->pulse == 0) + return; + + width = cell_area->width / 4; + height = cell_area->height / 4; + + x = cell_area->x + (cell_area->width / 2) - (width / 2) - xpad; + y = cell_area->y + (cell_area->height / 2) - (height / 2) - ypad; + + G_GNUC_BEGIN_IGNORE_DEPRECATIONS; + gtk_paint_spinner (gtk_widget_get_style (widget), + cr, + GTK_STATE_FLAG_ACTIVE, + widget, + NULL, + (guint) priv->pulse - 1, + x, y, + width, height); + G_GNUC_END_IGNORE_DEPRECATIONS; +} + +static void +gd_toggle_pixbuf_renderer_render (GtkCellRenderer *cell, + cairo_t *cr, + GtkWidget *widget, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, + GtkCellRendererState flags) +{ + gint icon_size = -1; + GdTogglePixbufRenderer *self = GD_TOGGLE_PIXBUF_RENDERER (cell); + gint xpad, ypad; + + GTK_CELL_RENDERER_CLASS (gd_toggle_pixbuf_renderer_parent_class)->render + (cell, cr, widget, + background_area, cell_area, flags); + + gtk_cell_renderer_get_padding (cell, &xpad, &ypad); + gtk_widget_style_get (widget, + "check-icon-size", &icon_size, + NULL); + + if (icon_size == -1) + icon_size = 40; + + render_activity (self, cr, widget, cell_area, icon_size, xpad, ypad); + render_check (self, cr, widget, cell_area, icon_size, xpad, ypad); +} + +static void +gd_toggle_pixbuf_renderer_get_size (GtkCellRenderer *cell, + GtkWidget *widget, + const GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height) +{ + gint icon_size; + + gtk_widget_style_get (widget, + "check-icon-size", &icon_size, + NULL); + + GTK_CELL_RENDERER_CLASS (gd_toggle_pixbuf_renderer_parent_class)->get_size + (cell, widget, cell_area, + x_offset, y_offset, width, height); + + *width += icon_size / 4; +} + +static void +gd_toggle_pixbuf_renderer_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GdTogglePixbufRenderer *self = GD_TOGGLE_PIXBUF_RENDERER (object); + GdTogglePixbufRendererPrivate *priv; + + priv = gd_toggle_pixbuf_renderer_get_instance_private (self); + + switch (property_id) + { + case PROP_ACTIVE: + g_value_set_boolean (value, priv->active); + break; + case PROP_TOGGLE_VISIBLE: + g_value_set_boolean (value, priv->toggle_visible); + break; + case PROP_PULSE: + g_value_set_uint (value, priv->pulse); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_toggle_pixbuf_renderer_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GdTogglePixbufRenderer *self = GD_TOGGLE_PIXBUF_RENDERER (object); + GdTogglePixbufRendererPrivate *priv; + + priv = gd_toggle_pixbuf_renderer_get_instance_private (self); + + switch (property_id) + { + case PROP_ACTIVE: + priv->active = g_value_get_boolean (value); + break; + case PROP_TOGGLE_VISIBLE: + priv->toggle_visible = g_value_get_boolean (value); + break; + case PROP_PULSE: + priv->pulse = g_value_get_uint (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_toggle_pixbuf_renderer_class_init (GdTogglePixbufRendererClass *klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + GtkCellRendererClass *crclass = GTK_CELL_RENDERER_CLASS (klass); + + crclass->render = gd_toggle_pixbuf_renderer_render; + crclass->get_size = gd_toggle_pixbuf_renderer_get_size; + oclass->get_property = gd_toggle_pixbuf_renderer_get_property; + oclass->set_property = gd_toggle_pixbuf_renderer_set_property; + + properties[PROP_ACTIVE] = + g_param_spec_boolean ("active", + "Active", + "Whether the cell renderer is active", + FALSE, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + properties[PROP_TOGGLE_VISIBLE] = + g_param_spec_boolean ("toggle-visible", + "Toggle visible", + "Whether to draw the toggle indicator", + FALSE, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + properties[PROP_PULSE] = + g_param_spec_uint ("pulse", + "Pulse", + "Set to any value other than 0 to display a " + "spinner on top of the pixbuf.", + 0, + G_MAXUINT, + 0, + G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, NUM_PROPERTIES, properties); +} + +static void +gd_toggle_pixbuf_renderer_init (GdTogglePixbufRenderer *self) +{ +} + +GtkCellRenderer * +gd_toggle_pixbuf_renderer_new (void) +{ + return g_object_new (GD_TYPE_TOGGLE_PIXBUF_RENDERER, NULL); +} diff --git a/subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.h b/subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.h new file mode 100644 index 0000000..93f4429 --- /dev/null +++ b/subprojects/libgd/libgd/gd-toggle-pixbuf-renderer.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef _GD_TOGGLE_PIXBUF_RENDERER_H +#define _GD_TOGGLE_PIXBUF_RENDERER_H + +#include + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_TOGGLE_PIXBUF_RENDERER gd_toggle_pixbuf_renderer_get_type() +G_DECLARE_DERIVABLE_TYPE (GdTogglePixbufRenderer, + gd_toggle_pixbuf_renderer, + GD, + TOGGLE_PIXBUF_RENDERER, + GtkCellRendererPixbuf) + +struct _GdTogglePixbufRendererClass +{ + GtkCellRendererPixbufClass parent_class; +}; + +GtkCellRenderer *gd_toggle_pixbuf_renderer_new (void); + +G_END_DECLS + +#endif /* _GD_TOGGLE_PIXBUF_RENDERER_H */ diff --git a/subprojects/libgd/libgd/gd-two-lines-renderer.c b/subprojects/libgd/libgd/gd-two-lines-renderer.c new file mode 100644 index 0000000..f5e1ce5 --- /dev/null +++ b/subprojects/libgd/libgd/gd-two-lines-renderer.c @@ -0,0 +1,632 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#include "gd-two-lines-renderer.h" +#include + +#define SUBTITLE_DIM_PERCENTAGE 0.55 +#define SUBTITLE_SIZE_PERCENTAGE 0.82 + +typedef struct _GdTwoLinesRendererPrivate GdTwoLinesRendererPrivate; + +struct _GdTwoLinesRendererPrivate { + gchar *line_two; + gint text_lines; +}; + +enum { + PROP_TEXT_LINES = 1, + PROP_LINE_TWO, + NUM_PROPERTIES +}; + +static GParamSpec *properties[NUM_PROPERTIES] = { NULL, }; + +G_DEFINE_TYPE_WITH_PRIVATE (GdTwoLinesRenderer, gd_two_lines_renderer, GTK_TYPE_CELL_RENDERER_TEXT) + +static PangoLayout * +create_layout_with_attrs (GtkWidget *widget, + const GdkRectangle *cell_area, + GdTwoLinesRenderer *self, + PangoEllipsizeMode ellipsize) +{ + PangoLayout *layout; + gint wrap_width, xpad; + PangoWrapMode wrap_mode; + PangoAlignment alignment; + + g_object_get (self, + "wrap-width", &wrap_width, + "wrap-mode", &wrap_mode, + "alignment", &alignment, + "xpad", &xpad, + NULL); + + layout = pango_layout_new (gtk_widget_get_pango_context (widget)); + + pango_layout_set_ellipsize (layout, ellipsize); + pango_layout_set_alignment (layout, alignment); + + if (wrap_width != -1) + { + pango_layout_set_width (layout, wrap_width * PANGO_SCALE); + pango_layout_set_wrap (layout, wrap_mode); + } + else + { + if (cell_area != NULL) + pango_layout_set_width (layout, (cell_area->width - 2 * xpad) * PANGO_SCALE); + else + pango_layout_set_width (layout, -1); + + pango_layout_set_wrap (layout, PANGO_WRAP_CHAR); + } + + return layout; +} + +static void +apply_subtitle_style_to_layout (GtkStyleContext *context, + PangoLayout *layout, + GtkStateFlags flags) +{ + PangoFontDescription *desc; + PangoAttrList *layout_attr; + PangoAttribute *attr_alpha; + + gtk_style_context_save (context); + gtk_style_context_set_state (context, flags); + gtk_style_context_get (context, gtk_style_context_get_state (context), + "font", &desc, + NULL); + gtk_style_context_restore (context); + + /* Set the font size */ + pango_font_description_set_size (desc, pango_font_description_get_size (desc) * SUBTITLE_SIZE_PERCENTAGE); + pango_layout_set_font_description (layout, desc); + pango_font_description_free (desc); + + /* Set the font alpha */ + layout_attr = pango_attr_list_new (); + attr_alpha = pango_attr_foreground_alpha_new (SUBTITLE_DIM_PERCENTAGE * 65535); + pango_attr_list_insert (layout_attr, attr_alpha); + + pango_layout_set_attributes (layout, layout_attr); + pango_attr_list_unref (layout_attr); +} + +static void +gd_two_lines_renderer_prepare_layouts (GdTwoLinesRenderer *self, + const GdkRectangle *cell_area, + GtkWidget *widget, + PangoLayout **layout_one, + PangoLayout **layout_two) +{ + GdTwoLinesRendererPrivate *priv; + PangoLayout *line_one; + PangoLayout *line_two = NULL; + gchar *text = NULL; + + priv = gd_two_lines_renderer_get_instance_private (self); + + g_object_get (self, + "text", &text, + NULL); + + line_one = create_layout_with_attrs (widget, cell_area, + self, PANGO_ELLIPSIZE_MIDDLE); + + if (priv->line_two == NULL || + g_strcmp0 (priv->line_two, "") == 0) + { + pango_layout_set_height (line_one, - (priv->text_lines)); + + if (text != NULL) + pango_layout_set_text (line_one, text, -1); + } + else + { + GtkStyleContext *context; + + line_two = create_layout_with_attrs (widget, cell_area, + self, PANGO_ELLIPSIZE_END); + + context = gtk_widget_get_style_context (widget); + gtk_style_context_save (context); + apply_subtitle_style_to_layout (context, line_two, GTK_STATE_FLAG_NORMAL); + gtk_style_context_restore (context); + + pango_layout_set_height (line_one, - (priv->text_lines - 1)); + pango_layout_set_height (line_two, -1); + pango_layout_set_text (line_two, priv->line_two, -1); + + if (text != NULL) + pango_layout_set_text (line_one, text, -1); + } + + if (layout_one) + *layout_one = line_one; + if (layout_two) + *layout_two = line_two; + + g_free (text); +} + +static void +gd_two_lines_renderer_get_size (GtkCellRenderer *cell, + GtkWidget *widget, + PangoLayout *layout_1, + PangoLayout *layout_2, + gint *width, + gint *height, + const GdkRectangle *cell_area, + gint *x_offset_1, + gint *x_offset_2, + gint *y_offset) +{ + GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell); + gint xpad, ypad; + PangoLayout *layout_one, *layout_two; + GdkRectangle layout_one_rect, layout_two_rect, layout_union; + + if (layout_1 == NULL) + { + gd_two_lines_renderer_prepare_layouts (self, cell_area, widget, &layout_one, &layout_two); + } + else + { + layout_one = g_object_ref (layout_1); + + if (layout_2 != NULL) + layout_two = g_object_ref (layout_2); + else + layout_two = NULL; + } + + gtk_cell_renderer_get_padding (cell, &xpad, &ypad); + pango_layout_get_pixel_extents (layout_one, NULL, (PangoRectangle *) &layout_one_rect); + + if (layout_two != NULL) + { + pango_layout_get_pixel_extents (layout_two, NULL, (PangoRectangle *) &layout_two_rect); + + layout_union.width = MAX (layout_one_rect.width, layout_two_rect.width); + layout_union.height = layout_one_rect.height + layout_two_rect.height; + } + else + { + layout_union = layout_one_rect; + } + + if (cell_area) + { + gfloat xalign, yalign; + + gtk_cell_renderer_get_alignment (cell, &xalign, &yalign); + + layout_union.width = MIN (layout_union.width, cell_area->width - 2 * xpad); + layout_union.height = MIN (layout_union.height, cell_area->height - 2 * ypad); + + if (x_offset_1) + { + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + *x_offset_1 = (1.0 - xalign) * (cell_area->width - (layout_one_rect.width + (2 * xpad))); + else + *x_offset_1 = xalign * (cell_area->width - (layout_one_rect.width + (2 * xpad))); + + *x_offset_1 = MAX (*x_offset_1, 0); + } + if (x_offset_2) + { + if (layout_two != NULL) + { + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + *x_offset_2 = (1.0 - xalign) * (cell_area->width - (layout_two_rect.width + (2 * xpad))); + else + *x_offset_2 = xalign * (cell_area->width - (layout_two_rect.width + (2 * xpad))); + + *x_offset_2 = MAX (*x_offset_2, 0); + } + else + { + *x_offset_2 = 0; + } + } + + if (y_offset) + { + *y_offset = yalign * (cell_area->height - (layout_union.height + (2 * ypad))); + *y_offset = MAX (*y_offset, 0); + } + } + else + { + if (x_offset_1) *x_offset_1 = 0; + if (x_offset_2) *x_offset_2 = 0; + if (y_offset) *y_offset = 0; + } + + g_clear_object (&layout_one); + g_clear_object (&layout_two); + + if (height) + *height = ypad * 2 + layout_union.height; + + if (width) + *width = xpad * 2 + layout_union.width; +} + +static void +gd_two_lines_renderer_render (GtkCellRenderer *cell, + cairo_t *cr, + GtkWidget *widget, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, + GtkCellRendererState flags) +{ + GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell); + GtkStyleContext *context; + gint line_one_height; + GtkStateFlags state; + GdkRectangle area, render_area = *cell_area; + gint xpad, ypad, x_offset_1, x_offset_2, y_offset; + PangoLayout *layout_one, *layout_two; + PangoRectangle layout_rect; + + /* fetch common information */ + context = gtk_widget_get_style_context (widget); + gd_two_lines_renderer_prepare_layouts (self, cell_area, widget, &layout_one, &layout_two); + gd_two_lines_renderer_get_size (cell, widget, + layout_one, layout_two, + NULL, NULL, + cell_area, + &x_offset_1, &x_offset_2, &y_offset); + gtk_cell_renderer_get_padding (cell, &xpad, &ypad); + + area = *cell_area; + area.x += xpad; + area.y += ypad; + + /* now render the first layout */ + pango_layout_get_pixel_extents (layout_one, NULL, &layout_rect); + + render_area = area; + render_area.x += x_offset_1 - layout_rect.x; + render_area.y += y_offset; + + gtk_render_layout (context, cr, + render_area.x, + render_area.y, + layout_one); + + /* render the second layout */ + if (layout_two != NULL) + { + pango_layout_get_pixel_size (layout_one, + NULL, &line_one_height); + + gtk_style_context_save (context); + + apply_subtitle_style_to_layout (context, layout_two, flags); + + state = gtk_cell_renderer_get_state (cell, widget, flags); + gtk_style_context_set_state (context, state); + + pango_layout_get_pixel_extents (layout_two, NULL, &layout_rect); + + render_area = area; + render_area.x += x_offset_2 - layout_rect.x; + render_area.y += y_offset + line_one_height; + + gtk_render_layout (context, cr, + render_area.x, + render_area.y, + layout_two); + + gtk_style_context_restore (context); + } + + g_clear_object (&layout_one); + g_clear_object (&layout_two); +} + +static void +gd_two_lines_renderer_get_preferred_width (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + PangoContext *context; + PangoFontMetrics *metrics; + PangoFontDescription *font_desc; + GtkStyleContext *style_context; + gint nat_width, min_width; + gint xpad, char_width, wrap_width, text_width; + gint width_chars, ellipsize_chars; + + g_object_get (cell, + "xpad", &xpad, + "width-chars", &width_chars, + "wrap-width", &wrap_width, + NULL); + style_context = gtk_widget_get_style_context (widget); + gtk_cell_renderer_get_padding (cell, &xpad, NULL); + + gd_two_lines_renderer_get_size (cell, widget, + NULL, NULL, + &text_width, NULL, + NULL, + NULL, NULL, NULL); + + /* Fetch the average size of a character */ + context = gtk_widget_get_pango_context (widget); + gtk_style_context_save (style_context); + gtk_style_context_set_state (style_context, 0); + gtk_style_context_get (style_context, gtk_style_context_get_state (style_context), + "font", &font_desc, NULL); + gtk_style_context_restore (style_context); + metrics = pango_context_get_metrics (context, font_desc, + pango_context_get_language (context)); + + char_width = pango_font_metrics_get_approximate_char_width (metrics); + + pango_font_metrics_unref (metrics); + pango_font_description_free (font_desc); + + /* enforce minimum width for ellipsized labels at ~3 chars */ + ellipsize_chars = 3; + + /* If no width-chars set, minimum for wrapping text will be the wrap-width */ + if (wrap_width > -1) + min_width = xpad * 2 + MIN (text_width, wrap_width); + else + min_width = xpad * 2 + + MIN (text_width, + (PANGO_PIXELS (char_width) * MAX (width_chars, ellipsize_chars))); + + if (width_chars > 0) + nat_width = xpad * 2 + + MAX ((PANGO_PIXELS (char_width) * width_chars), text_width); + else + nat_width = xpad * 2 + text_width; + + nat_width = MAX (nat_width, min_width); + + if (minimum_size) + *minimum_size = min_width; + + if (natural_size) + *natural_size = nat_width; +} + +static void +gd_two_lines_renderer_get_preferred_height_for_width (GtkCellRenderer *cell, + GtkWidget *widget, + gint width, + gint *minimum_size, + gint *natural_size) +{ + GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell); + PangoLayout *layout_one, *layout_two; + gint text_height, wrap_width; + gint xpad, ypad; + + gtk_cell_renderer_get_padding (cell, &xpad, &ypad); + g_object_get (cell, "wrap-width", &wrap_width, NULL); + gd_two_lines_renderer_prepare_layouts (self, NULL, widget, &layout_one, &layout_two); + + if (wrap_width != -1) + wrap_width = MIN (width - 2 * xpad, wrap_width); + else + wrap_width = width - 2 * xpad; + + pango_layout_set_width (layout_one, wrap_width); + if (layout_two != NULL) + pango_layout_set_width (layout_two, wrap_width); + + gd_two_lines_renderer_get_size (cell, widget, + layout_one, layout_two, + NULL, &text_height, + NULL, + NULL, NULL, NULL); + + text_height += 2 * ypad; + + if (minimum_size != NULL) + *minimum_size = text_height; + + if (natural_size != NULL) + *natural_size = text_height; + + g_clear_object (&layout_one); + g_clear_object (&layout_two); +} + +static void +gd_two_lines_renderer_get_preferred_height (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + gint min_width; + + gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, NULL); + gd_two_lines_renderer_get_preferred_height_for_width (cell, widget, min_width, + minimum_size, natural_size); +} + +static void +gd_two_lines_renderer_get_aligned_area (GtkCellRenderer *cell, + GtkWidget *widget, + GtkCellRendererState flags, + const GdkRectangle *cell_area, + GdkRectangle *aligned_area) +{ + gint x_offset, x_offset_1, x_offset_2, y_offset; + + /* fetch common information */ + gd_two_lines_renderer_get_size (cell, widget, + NULL, NULL, + &aligned_area->width, &aligned_area->height, + cell_area, + &x_offset_1, &x_offset_2, &y_offset); + + x_offset = MIN (x_offset_1, x_offset_2); + + aligned_area->x = cell_area->x + x_offset; + aligned_area->y = cell_area->y + y_offset; +} + +static void +gd_two_lines_renderer_set_line_two (GdTwoLinesRenderer *self, + const gchar *line_two) +{ + GdTwoLinesRendererPrivate *priv; + + priv = gd_two_lines_renderer_get_instance_private (self); + + if (g_strcmp0 (priv->line_two, line_two) == 0) + return; + + g_free (priv->line_two); + priv->line_two = g_strdup (line_two); + + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LINE_TWO]); +} + +static void +gd_two_lines_renderer_set_text_lines (GdTwoLinesRenderer *self, + gint text_lines) +{ + GdTwoLinesRendererPrivate *priv; + + priv = gd_two_lines_renderer_get_instance_private (self); + + if (priv->text_lines == text_lines) + return; + + priv->text_lines = text_lines; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TEXT_LINES]); +} + +static void +gd_two_lines_renderer_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (object); + + switch (property_id) + { + case PROP_TEXT_LINES: + gd_two_lines_renderer_set_text_lines (self, g_value_get_int (value)); + break; + case PROP_LINE_TWO: + gd_two_lines_renderer_set_line_two (self, g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_two_lines_renderer_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (object); + GdTwoLinesRendererPrivate *priv; + + priv = gd_two_lines_renderer_get_instance_private (self); + + switch (property_id) + { + case PROP_TEXT_LINES: + g_value_set_int (value, priv->text_lines); + break; + case PROP_LINE_TWO: + g_value_set_string (value, priv->line_two); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gd_two_lines_renderer_finalize (GObject *object) +{ + GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (object); + GdTwoLinesRendererPrivate *priv; + + priv = gd_two_lines_renderer_get_instance_private (self); + + g_free (priv->line_two); + + G_OBJECT_CLASS (gd_two_lines_renderer_parent_class)->finalize (object); +} + +static void +gd_two_lines_renderer_class_init (GdTwoLinesRendererClass *klass) +{ + GtkCellRendererClass *cclass = GTK_CELL_RENDERER_CLASS (klass); + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + cclass->render = gd_two_lines_renderer_render; + cclass->get_preferred_width = gd_two_lines_renderer_get_preferred_width; + cclass->get_preferred_height = gd_two_lines_renderer_get_preferred_height; + cclass->get_preferred_height_for_width = gd_two_lines_renderer_get_preferred_height_for_width; + cclass->get_aligned_area = gd_two_lines_renderer_get_aligned_area; + + oclass->set_property = gd_two_lines_renderer_set_property; + oclass->get_property = gd_two_lines_renderer_get_property; + oclass->finalize = gd_two_lines_renderer_finalize; + + properties[PROP_TEXT_LINES] = + g_param_spec_int ("text-lines", + "Lines of text", + "The total number of lines to be displayed", + 2, G_MAXINT, 2, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + properties[PROP_LINE_TWO] = + g_param_spec_string ("line-two", + "Second line", + "Second line", + NULL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, NUM_PROPERTIES, properties); +} + +static void +gd_two_lines_renderer_init (GdTwoLinesRenderer *self) +{ +} + +GtkCellRenderer * +gd_two_lines_renderer_new (void) +{ + return g_object_new (GD_TYPE_TWO_LINES_RENDERER, NULL); +} diff --git a/subprojects/libgd/libgd/gd-two-lines-renderer.h b/subprojects/libgd/libgd/gd-two-lines-renderer.h new file mode 100644 index 0000000..113191b --- /dev/null +++ b/subprojects/libgd/libgd/gd-two-lines-renderer.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2011 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: Cosimo Cecchi + * + */ + +#ifndef _GD_TWO_LINES_RENDERER_H +#define _GD_TWO_LINES_RENDERER_H + +#include + +#include + +G_BEGIN_DECLS + +#define GD_TYPE_TWO_LINES_RENDERER gd_two_lines_renderer_get_type() +G_DECLARE_DERIVABLE_TYPE (GdTwoLinesRenderer, gd_two_lines_renderer, GD, TWO_LINES_RENDERER, GtkCellRendererText) + +struct _GdTwoLinesRendererClass +{ + GtkCellRendererTextClass parent_class; +}; + +GtkCellRenderer *gd_two_lines_renderer_new (void); + +G_END_DECLS + +#endif /* _GD_TWO_LINES_RENDERER_H */ diff --git a/subprojects/libgd/libgd/gd-types-catalog.c b/subprojects/libgd/libgd/gd-types-catalog.c new file mode 100644 index 0000000..75f7d57 --- /dev/null +++ b/subprojects/libgd/libgd/gd-types-catalog.c @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2012 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "gd-types-catalog.h" + +#ifdef LIBGD__BOX_COMMON +# include "gd-main-box-child.h" +# include "gd-main-box-generic.h" +# include "gd-main-box-item.h" +#endif + +#ifdef LIBGD_MAIN_ICON_BOX +# include "gd-main-icon-box.h" +# include "gd-main-icon-box-child.h" +#endif + +#ifdef LIBGD_MAIN_BOX +# include "gd-main-box.h" +#endif + +#ifdef LIBGD__VIEW_COMMON +# include "gd-main-view-generic.h" +# include "gd-styled-text-renderer.h" +# include "gd-two-lines-renderer.h" +#endif + +#ifdef LIBGD_MAIN_ICON_VIEW +# include "gd-main-icon-view.h" +# include "gd-toggle-pixbuf-renderer.h" +#endif + +#ifdef LIBGD_MAIN_LIST_VIEW +# include "gd-main-list-view.h" +#endif + +#ifdef LIBGD_MAIN_VIEW +# include "gd-main-view.h" +#endif + +#ifdef LIBGD_MARGIN_CONTAINER +# include "gd-margin-container.h" +#endif + +#ifdef LIBGD_TAGGED_ENTRY +# include "gd-tagged-entry.h" +#endif + +#ifdef LIBGD_NOTIFICATION +# include "gd-notification.h" +#endif + +/** + * gd_ensure_types: + * + * This functions must be called during initialization + * to make sure the widget types are available to GtkBuilder. + */ +void +gd_ensure_types (void) +{ +#ifdef LIBGD__BOX_COMMON + g_type_ensure (GD_TYPE_MAIN_BOX_CHILD); + g_type_ensure (GD_TYPE_MAIN_BOX_GENERIC); + g_type_ensure (GD_TYPE_MAIN_BOX_ITEM); +#endif + +#ifdef LIBGD_MAIN_ICON_BOX + g_type_ensure (GD_TYPE_MAIN_ICON_BOX); + g_type_ensure (GD_TYPE_MAIN_ICON_BOX_CHILD); +#endif + +#ifdef LIBGD_MAIN_BOX + g_type_ensure (GD_TYPE_MAIN_BOX); +#endif + +#ifdef LIBGD__VIEW_COMMON + g_type_ensure (GD_TYPE_MAIN_VIEW_GENERIC); + g_type_ensure (GD_TYPE_STYLED_TEXT_RENDERER); + g_type_ensure (GD_TYPE_TWO_LINES_RENDERER); +#endif + +#ifdef LIBGD_MAIN_ICON_VIEW + g_type_ensure (GD_TYPE_MAIN_ICON_VIEW); + g_type_ensure (GD_TYPE_TOGGLE_PIXBUF_RENDERER); +#endif + +#ifdef LIBGD_MAIN_LIST_VIEW + g_type_ensure (GD_TYPE_MAIN_LIST_VIEW); +#endif + +#ifdef LIBGD_MAIN_VIEW + g_type_ensure (GD_TYPE_MAIN_VIEW); +#endif + +#ifdef LIBGD_MARGIN_CONTAINER + g_type_ensure (GD_TYPE_MARGIN_CONTAINER); +#endif + +#ifdef LIBGD_TAGGED_ENTRY + g_type_ensure (GD_TYPE_TAGGED_ENTRY); +#endif + +#ifdef LIBGD_NOTIFICATION + g_type_ensure (GD_TYPE_NOTIFICATION); +#endif +} + diff --git a/subprojects/libgd/libgd/gd-types-catalog.h b/subprojects/libgd/libgd/gd-types-catalog.h new file mode 100644 index 0000000..fc99416 --- /dev/null +++ b/subprojects/libgd/libgd/gd-types-catalog.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2012 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GD_TYPES_CATALOG_H__ +#define __GD_TYPES_CATALOG_H__ + +#include + +G_BEGIN_DECLS + +void gd_ensure_types (void); + +G_END_DECLS + +#endif /* __GD_TYPES_CATALOG_H__ */ diff --git a/subprojects/libgd/libgd/gd.h b/subprojects/libgd/libgd/gd.h new file mode 100644 index 0000000..69685c9 --- /dev/null +++ b/subprojects/libgd/libgd/gd.h @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2012 Red Hat, Inc. + * + * This program is free software; you can redistribute 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GD_H__ +#define __GD_H__ + +#include + +G_BEGIN_DECLS + +#include + +#ifdef LIBGD_GTK_HACKS +# include +#endif + +#ifdef LIBGD__BOX_COMMON +# include +# include +# include +#endif + +#ifdef LIBGD_MAIN_ICON_BOX +# include +# include +#endif + +#ifdef LIBGD_MAIN_BOX +# include +#endif + +#ifdef LIBGD__VIEW_COMMON +# include +# include +# include +#endif + +#ifdef LIBGD_MAIN_ICON_VIEW +# include +# include +#endif + +#ifdef LIBGD_MAIN_LIST_VIEW +# include +#endif + +#ifdef LIBGD_MAIN_VIEW +# include +#endif + +#ifdef LIBGD_MARGIN_CONTAINER +# include +#endif + +#ifdef LIBGD_TAGGED_ENTRY +# include +#endif + +#ifdef LIBGD_NOTIFICATION +# include +#endif + +G_END_DECLS + +#endif /* __GD_H__ */ diff --git a/subprojects/libgd/libgd/meson.build b/subprojects/libgd/libgd/meson.build new file mode 100644 index 0000000..6ba7871 --- /dev/null +++ b/subprojects/libgd/libgd/meson.build @@ -0,0 +1,204 @@ +gnome = import('gnome') + +sources = [ + 'gd.h', + 'gd-types-catalog.c' +] +built_sources = [] +c_args = [] +private_c_args = [ + '-DG_LOG_DOMAIN="libgd"', + '-DG_DISABLE_DEPRECATED', +] + +if (get_option('with-gtk-hacks') or + get_option('with-main-box') or + get_option('with-main-icon-box') or + get_option('with-main-view')) + sources += [ + 'gd-icon-utils.c', + 'gd-icon-utils.h', + ] + c_args += '-DLIBGD_GTK_HACKS=1' +endif + +if (get_option('with-main-box') or + get_option('with-main-icon-box')) + sources += [ + 'gd-main-box-child.c', + 'gd-main-box-child.h', + 'gd-main-box-generic.c', + 'gd-main-box-generic.h', + 'gd-main-box-item.c', + 'gd-main-box-item.h' + ] + c_args += '-DLIBGD__BOX_COMMON=1' + + if (get_option('with-main-box') or + get_option('with-main-icon-box')) + sources += [ + 'gd-main-icon-box.c', + 'gd-main-icon-box.h', + 'gd-main-icon-box-child.c', + 'gd-main-icon-box-child.h', + 'gd-main-icon-box-icon.c', + 'gd-main-icon-box-icon.h', + 'gd-icon-utils.c', + 'gd-icon-utils.h', + ] + c_args += '-DLIBGD_MAIN_ICON_BOX=1' + endif + + if get_option('with-main-box') + sources += [ + 'gd-main-box.c', + 'gd-main-box.h', + ] + c_args += '-DLIBGD_MAIN_BOX=1' + endif +endif + +if (get_option('with-main-icon-view') or + get_option('with-main-list-view') or + get_option('with-main-view')) + sources += [ + 'gd-main-view-generic.c', + 'gd-main-view-generic.h', + 'gd-styled-text-renderer.c', + 'gd-styled-text-renderer.h', + 'gd-two-lines-renderer.c', + 'gd-two-lines-renderer.h', + ] + c_args += '-DLIBGD__VIEW_COMMON=1' + + if (get_option('with-main-icon-view') or + get_option('with-main-view')) + sources += [ + 'gd-main-icon-view.c', + 'gd-main-icon-view.h', + 'gd-toggle-pixbuf-renderer.c', + 'gd-toggle-pixbuf-renderer.h' + ] + c_args += '-DLIBGD_MAIN_ICON_VIEW=1' + endif + + if (get_option('with-main-list-view') or + get_option('with-main-view')) + sources += [ + 'gd-main-list-view.c', + 'gd-main-list-view.h', + ] + c_args += '-DLIBGD_MAIN_LIST_VIEW=1' + endif + + if get_option('with-main-view') + sources += [ + 'gd-main-view.c', + 'gd-main-view.h', + ] + c_args += '-DLIBGD_MAIN_VIEW=1' + endif +endif + +if get_option('with-margin-container') + sources += [ + 'gd-margin-container.c', + 'gd-margin-container.h', + ] + c_args += '-DLIBGD_MARGIN_CONTAINER=1' +endif + +if get_option('with-tagged-entry') + sources += [ + 'gd-tagged-entry.c', + 'gd-tagged-entry.h', + ] + c_args += '-DLIBGD_TAGGED_ENTRY=1' +endif + +if get_option('with-notification') + sources += [ + 'gd-notification.c', + 'gd-notification.h', + ] + c_args += '-DLIBGD_NOTIFICATION=1' +endif + +if sources.length() == 2 + error('You must include a feature to be built!') +endif + +# --------- Building ----------- + +static = get_option('static') +install_introspection = get_option('with-introspection') +with_vapi = get_option('with-vapi') + +if static + libgd_lib = static_library('gd', sources, + dependencies: [libgtk, libm], + include_directories: libgd_include, + c_args: c_args + private_c_args + ) +endif + +# Currently in Meson building gir requires a shared library +if not static or (install_introspection or with_vapi) + if not static and pkglibdir == '' + error('Installing shared library but pkglibdir is unset!') + endif + + libgd_shared_lib = shared_library('gd', sources, + dependencies: [libgtk, libm], + include_directories: libgd_include, + c_args: c_args + private_c_args, + install: not static, + install_dir: pkglibdir + ) + + if not static + libgd_lib = libgd_shared_lib + endif +endif + +if install_introspection or with_vapi + if install_introspection + if pkgdatadir == '' + error('Installing introspection but pkgdatadir is unset!') + elif pkglibdir == '' + error('Installing introspection but pkglibdir is unset!') + endif + endif + + libgd_gir = gnome.generate_gir(libgd_shared_lib, + sources : sources, + nsversion : '1.0', + namespace : 'Gd', + symbol_prefix : 'gd', + identifier_prefix : 'Gd', + includes : 'Gtk-3.0', + include_directories: libgd_include, + install: install_introspection, + install_dir_gir: join_paths(pkgdatadir, 'gir-1.0'), + install_dir_typelib: join_paths(pkglibdir, 'girepository-1.0'), + extra_args: [ + '--c-include=libgd/gd.h', + ] + ) + built_sources += libgd_gir + + if get_option('with-vapi') + libgd_vapi_dep = gnome.generate_vapi('gd-1.0', + sources: libgd_gir[0], + packages: ['gtk+-3.0'] + ) + endif +endif + +libgd_dep = declare_dependency( + link_with: libgd_lib, + include_directories: libgd_include, + dependencies: libgtk, + compile_args: c_args, + sources: built_sources +) diff --git a/subprojects/libgd/meson.build b/subprojects/libgd/meson.build new file mode 100644 index 0000000..6d1242c --- /dev/null +++ b/subprojects/libgd/meson.build @@ -0,0 +1,24 @@ +project('libgd', 'c', + meson_version: '>= 0.38.0', + default_options: ['static=true'], +) + +if not meson.is_subproject() + message('WARNING: This project is only intended to be used as a subproject!') +endif + +pkglibdir = get_option('pkglibdir') +pkgdatadir = get_option('pkgdatadir') + +libgtk = dependency('gtk+-3.0', version: '>= 3.7.10') +cc = meson.get_compiler('c') +libm = cc.find_library('m', required: false) +libgd_include = include_directories('.') + +subdir('libgd') + +if get_option('with-tagged-entry') + foreach t : ['test-tagged-entry', 'test-tagged-entry-2'] + executable(t, t + '.c', dependencies : libgd_dep) + endforeach +endif diff --git a/subprojects/libgd/meson_options.txt b/subprojects/libgd/meson_options.txt new file mode 100644 index 0000000..fcab3a0 --- /dev/null +++ b/subprojects/libgd/meson_options.txt @@ -0,0 +1,25 @@ +option('pkglibdir', type: 'string', value: '', + description: 'The private directory the shared library/typelib will be installed into.' +) +option('pkgdatadir', type: 'string', value: '', + description: 'The private directory the gir file will be installed into.' +) +option('static', type: 'boolean', value: false, + description: 'Build as a static library' +) +option('with-introspection', type: 'boolean', value: false, + description: 'Build gobject-introspection support' +) +option('with-vapi', type: 'boolean', value: false, + description: 'Build vapi file' +) +# Widget options +option('with-gtk-hacks', type: 'boolean', value: false) +option('with-main-view', type: 'boolean', value: false) +option('with-main-icon-view', type: 'boolean', value: false) +option('with-main-list-view', type: 'boolean', value: false) +option('with-margin-container', type: 'boolean', value: false) +option('with-tagged-entry', type: 'boolean', value: false) +option('with-notification', type: 'boolean', value: false) +option('with-main-box', type: 'boolean', value: false) +option('with-main-icon-box', type: 'boolean', value: false) \ No newline at end of file diff --git a/subprojects/libgd/meson_readme.md b/subprojects/libgd/meson_readme.md new file mode 100644 index 0000000..c3e7f26 --- /dev/null +++ b/subprojects/libgd/meson_readme.md @@ -0,0 +1,88 @@ +See README for general information. Read below for usage with Meson. + +Usage +===== + +libgd is intended to be used as a submodule from other projects. This requires passing default_options to the subproject +which was added in Meson 0.38.0. To see a full list of options you can run `mesonconf $your_build_dir`. If building a +non-static library `pkglibdir` must be set to a private location to install to which you will also want to pass (an absolute path) +with the `install_rpath` keyword to any executables. For introspection files you also must set `pkgdatadir`. + +So given a Meson project using git you would run this to do initial setup: + +``` +mkdir subprojects +git submodule add https://git.gnome.org/browse/libgd subprojects/libgd +``` + +Then from within your `meson.build` file: + +Static Library +-------------- + +```meson +libgd = subproject('libgd', + default_options: [ + 'with-tagged-entry=true' + ] +) +# Pass as dependency to another target +libgd_dep = libgd.get_variable('libgd_dep') +``` + +```c +#include "libgd/gd.h" + +int main(int argc, char **argv) +{ + gd_ensure_types(); /* As a test */ + return 0; +} +``` + +Introspection +------------- + +```meson +pkglibdir = join_paths(get_option('libdir'), meson.project_name()) +pkgdatadir = join_paths(get_option('datadir'), meson.project_name()) +libgd = subproject('libgd', + default_options: [ + 'pkglibdir=' + pkglibdir, + 'pkgdatadir=' + pkgdatadir, + 'with-tagged-entry=true', + 'with-introspection=true', + 'static=false', + ] +) +``` + +```python +import os +import gi +gi.require_version('GIRepository', '2.0') +from gi.repository import GIRepository +pkglibdir = '/usr/lib/foo' # This would be defined at build time +pkggirdir = os.path.join(pkglibdir, 'girepository-1.0') +GIRepository.Repository.prepend_search_path(pkggirdir) +GIRepository.Repository.prepend_library_path(pkglibdir) +gi.require_version('Gd', '1.0') +``` + +Vala +---- + +```meson +pkglibdir = join_paths(get_option('libdir'), meson.project_name()) +libgd = subproject('libgd', + default_options: [ + 'pkglibdir=' + pkglibdir, + 'with-tagged-entry=true', + 'with-vapi=true' + ] +) +# Pass as dependency to a Vala target +libgd_vapi_dep = libgd.get_variable('libgd_vapi_dep') +``` + + diff --git a/subprojects/libgd/test-tagged-entry-2.c b/subprojects/libgd/test-tagged-entry-2.c new file mode 100644 index 0000000..465ab83 --- /dev/null +++ b/subprojects/libgd/test-tagged-entry-2.c @@ -0,0 +1,131 @@ +#include +#include + +static GdTaggedEntryTag *toggle_tag; + +static void +on_tag_clicked (GdTaggedEntry *entry, + GdTaggedEntryTag *tag, + gpointer useless) +{ + g_print ("tag clicked: %s\n", gd_tagged_entry_tag_get_label (tag)); +} + +static void +on_tag_button_clicked (GdTaggedEntry *entry, + GdTaggedEntryTag *tag, + gpointer useless) +{ + g_print ("tag button clicked: %s\n", gd_tagged_entry_tag_get_label (tag)); +} + +static void +on_toggle_visible (GtkButton *button, + GtkWidget *entry) +{ + gboolean active; + + active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)); + + g_print ("%s tagged entry\n", active ? "show" : "hide"); + gtk_widget_set_visible (entry, active); +} + +static void +on_toggle_tag (GtkButton *button, + GdTaggedEntry *entry) +{ + gboolean active; + + active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)); + + if (active) + { + g_print ("adding tag 'Toggle Tag'\n"); + gd_tagged_entry_insert_tag (entry, toggle_tag, 0); + } + else + { + g_print ("removing tag 'Toggle Tag'\n"); + gd_tagged_entry_remove_tag (entry, toggle_tag); + } +} + +gint +main (gint argc, + gchar ** argv) +{ + GtkWidget *box; + GtkWidget *entry; + GtkWidget *search_bar; + GtkWidget *search_container; + GtkWidget *toggle_tag_button; + GtkWidget *toggle_visible_button; + GtkWidget *revealer; + GtkWidget *window; + GdTaggedEntryTag *tag; + + gtk_init (&argc, &argv); + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_widget_set_size_request (window, 640, 600); + + box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_container_add (GTK_CONTAINER (window), box); + + revealer = gtk_revealer_new (); + gtk_revealer_set_reveal_child (GTK_REVEALER (revealer), TRUE); + gtk_container_add (GTK_CONTAINER (box), revealer); + + search_bar = gtk_search_bar_new (); + gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (search_bar), TRUE); + gtk_container_add (GTK_CONTAINER (revealer), search_bar); + + search_container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + gtk_widget_set_halign (search_container, GTK_ALIGN_CENTER); + gtk_container_add (GTK_CONTAINER (search_bar), search_container); + + entry = GTK_WIDGET (gd_tagged_entry_new ()); + gtk_widget_set_size_request (entry, 500, -1); + g_signal_connect (entry, "tag-clicked", + G_CALLBACK (on_tag_clicked), NULL); + g_signal_connect (entry, "tag-button-clicked", + G_CALLBACK (on_tag_button_clicked), NULL); + gtk_container_add (GTK_CONTAINER (search_container), entry); + + tag = gd_tagged_entry_tag_new ("Blah1"); + gd_tagged_entry_add_tag (GD_TAGGED_ENTRY (entry), tag); + g_object_unref (tag); + + tag = gd_tagged_entry_tag_new ("Blah2"); + gd_tagged_entry_tag_set_has_close_button (tag, FALSE); + gd_tagged_entry_insert_tag (GD_TAGGED_ENTRY (entry), tag, -1); + g_object_unref (tag); + + tag = gd_tagged_entry_tag_new ("Blah3"); + gd_tagged_entry_tag_set_has_close_button (tag, FALSE); + gd_tagged_entry_insert_tag (GD_TAGGED_ENTRY (entry), tag, 0); + g_object_unref (tag); + + toggle_visible_button = gtk_toggle_button_new_with_label ("Visible"); + gtk_widget_set_vexpand (toggle_visible_button, TRUE); + gtk_widget_set_valign (toggle_visible_button, GTK_ALIGN_END); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_visible_button), TRUE); + g_signal_connect (toggle_visible_button, "toggled", + G_CALLBACK (on_toggle_visible), entry); + gtk_container_add (GTK_CONTAINER (box), toggle_visible_button); + + toggle_tag = gd_tagged_entry_tag_new ("Toggle Tag"); + + toggle_tag_button = gtk_toggle_button_new_with_label ("Toggle Tag"); + g_signal_connect (toggle_tag_button, "toggled", + G_CALLBACK (on_toggle_tag), entry); + gtk_container_add (GTK_CONTAINER (box), toggle_tag_button); + + gtk_widget_show_all (window); + gtk_main (); + + gtk_widget_destroy (window); + + return 0; +} diff --git a/subprojects/libgd/test-tagged-entry.c b/subprojects/libgd/test-tagged-entry.c new file mode 100644 index 0000000..0f583d9 --- /dev/null +++ b/subprojects/libgd/test-tagged-entry.c @@ -0,0 +1,111 @@ +#include +#include + +static GdTaggedEntryTag *toggle_tag; + +static void +on_tag_clicked (GdTaggedEntry *entry, + GdTaggedEntryTag *tag, + gpointer useless) +{ + g_print ("tag clicked: %s\n", gd_tagged_entry_tag_get_label (tag)); +} + +static void +on_tag_button_clicked (GdTaggedEntry *entry, + GdTaggedEntryTag *tag, + gpointer useless) +{ + g_print ("tag button clicked: %s\n", gd_tagged_entry_tag_get_label (tag)); +} + +static void +on_toggle_visible (GtkButton *button, + GtkWidget *entry) +{ + gboolean active; + + active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)); + + g_print ("%s tagged entry\n", active ? "show" : "hide"); + gtk_widget_set_visible (entry, active); +} + +static void +on_toggle_tag (GtkButton *button, + GdTaggedEntry *entry) +{ + gboolean active; + + active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)); + + if (active) + { + g_print ("adding tag 'Toggle Tag'\n"); + gd_tagged_entry_insert_tag (entry, toggle_tag, 0); + } + else + { + g_print ("removing tag 'Toggle Tag'\n"); + gd_tagged_entry_remove_tag (entry, toggle_tag); + } +} + +gint +main (gint argc, + gchar ** argv) +{ + GtkWidget *window, *box, *entry, *toggle_visible_button, *toggle_tag_button; + GdTaggedEntryTag *tag; + + gtk_init (&argc, &argv); + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_widget_set_size_request (window, 300, 0); + + box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_container_add (GTK_CONTAINER (window), box); + + entry = GTK_WIDGET (gd_tagged_entry_new ()); + g_signal_connect(entry, "tag-clicked", + G_CALLBACK (on_tag_clicked), NULL); + g_signal_connect(entry, "tag-button-clicked", + G_CALLBACK (on_tag_button_clicked), NULL); + gtk_container_add (GTK_CONTAINER (box), entry); + + tag = gd_tagged_entry_tag_new ("Blah1"); + gd_tagged_entry_add_tag (GD_TAGGED_ENTRY (entry), tag); + g_object_unref (tag); + + tag = gd_tagged_entry_tag_new ("Blah2"); + gd_tagged_entry_tag_set_has_close_button (tag, FALSE); + gd_tagged_entry_insert_tag (GD_TAGGED_ENTRY (entry), tag, -1); + g_object_unref (tag); + + tag = gd_tagged_entry_tag_new ("Blah3"); + gd_tagged_entry_tag_set_has_close_button (tag, FALSE); + gd_tagged_entry_insert_tag (GD_TAGGED_ENTRY (entry), tag, 0); + g_object_unref (tag); + + toggle_visible_button = gtk_toggle_button_new_with_label ("Visible"); + gtk_widget_set_vexpand (toggle_visible_button, TRUE); + gtk_widget_set_valign (toggle_visible_button, GTK_ALIGN_END); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_visible_button), TRUE); + g_signal_connect (toggle_visible_button, "toggled", + G_CALLBACK (on_toggle_visible), entry); + gtk_container_add (GTK_CONTAINER (box), toggle_visible_button); + + toggle_tag = gd_tagged_entry_tag_new ("Toggle Tag"); + + toggle_tag_button = gtk_toggle_button_new_with_label ("Toggle Tag"); + g_signal_connect (toggle_tag_button, "toggled", + G_CALLBACK (on_toggle_tag), entry); + gtk_container_add (GTK_CONTAINER (box), toggle_tag_button); + + gtk_widget_show_all (window); + gtk_main (); + + gtk_widget_destroy (window); + + return 0; +} -- cgit v1.2.3