girara-0.2.5/AUTHORS0000644000175000017500000000103212512771304012475 0ustar mockmockgirara is written by: Moritz Lipp Sebastian Ramacher Other contributors are (in no particular order): Pavel Borzenkov William Dealey Oliver Mader Maxime de Roucy Marwan Tanager Benoît Knecht Abdó Roig-Maranges Alexey Galakhov Benoît Taine Alexander Shabalin girara-0.2.5/LICENSE0000644000175000017500000000153712513025726012445 0ustar mockmockCopyright (c) 2010-2015 pwmt.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. girara-0.2.5/Makefile0000644000175000017500000002107612635750323013103 0ustar mockmock# See LICENSE file for license and copyright information include config.mk include colors.mk include common.mk PROJECTNV = girara PROJECT = girara-gtk3 SOURCE = $(wildcard ${PROJECTNV}/*.c) CSOURCE = $(filter-out ${PROJECTNV}/css-definitions.c, ${SOURCE}) OBJECTS = $(addprefix ${BUILDDIR_RELEASE}/,${CSOURCE:.c=.o}) \ ${BUILDDIR_RELEASE}/${PROJECTNV}/css-definitions.o OBJECTS_DEBUG = $(addprefix ${BUILDDIR_DEBUG}/,${CSOURCE:.c=.o}) \ ${BUILDDIR_DEBUG}/${PROJECTNV}/css-definitions.o OBJECTS_GCOV = $(addprefix ${BUILDDIR_GCOV}/,${CSOURCE:.c=.o}) \ ${BUILDDIR_GCOV}/${PROJECTNV}/css-definitions.o HEADERS = $(filter-out ${PROJECTNV}/internal.h, $(wildcard ${PROJECTNV}/*.h)) ifneq (${WITH_LIBNOTIFY},0) CPPFLAGS += -DWITH_LIBNOTIFY LIBNOTIFY_PC_NAME = libnotify else LIBNOTIFY_PC_NAME = endif ifneq (${WITH_JSON},0) CPPFLAGS += -DWITH_JSON JSON_PC_NAME = json-c else JSON_PC_NAME = endif ifeq (,$(findstring -DGETTEXT_PACKAGE,${CPPFLAGS})) CPPFLAGS += -DGETTEXT_PACKAGE=\"${GETTEXT_PACKAGE}\" endif ifeq (,$(findstring -DLOCALEDIR,${CPPFLAGS})) CPPFLAGS += -DLOCALEDIR=\"${LOCALEDIR}\" endif UNAME := $(shell uname -s) ifeq ($(UNAME), Darwin) SONAME_FLAG = -install_name SHARED_FLAG = -dynamiclib endif all: ${PROJECTNV} ${BUILDDIR}/${PROJECT}.pc po # pkg-config based version checks .version-checks/%: config.mk $(QUIET)test $($(*)_VERSION_CHECK) -eq 0 || \ ${PKG_CONFIG} --atleast-version $($(*)_MIN_VERSION) $($(*)_PKG_CONFIG_NAME) || ( \ echo "The minimum required version of $(*) is $($(*)_MIN_VERSION)" && \ false \ ) @mkdir -p .version-checks $(QUIET)touch $@ options: @echo ${PROJECTNV} build options: @echo "CFLAGS = ${CFLAGS}" @echo "LDFLAGS = ${LDFLAGS}" @echo "DFLAGS = ${DFLAGS}" @echo "CC = ${CC}" # generated files ${PROJECTNV}/version.h: ${PROJECTNV}/version.h.in config.mk $(call colorecho,GEN,$@) $(QUIET)sed \ -e 's,@GVMAJOR@,${GIRARA_VERSION_MAJOR},' \ -e 's,@GVMINOR@,${GIRARA_VERSION_MINOR},' \ -e 's,@GVREV@,${GIRARA_VERSION_REV},' \ ${PROJECTNV}/version.h.in > ${PROJECTNV}/version.h.tmp $(QUIET)mv ${PROJECTNV}/version.h.tmp ${PROJECTNV}/version.h ${PROJECTNV}/css-definitions.c: data/girara.css_t $(call colorecho,GEN,$@) $(QUIET)echo '#include "css-definitions.h"' > $@.tmp $(QUIET)echo 'const char* CSS_TEMPLATE =' >> $@.tmp $(QUIET)sed 's/^\(.*\)$$/"\1\\n"/' $< >> $@.tmp $(QUIET)echo ';' >> $@.tmp $(QUIET)mv $@.tmp $@ ${BUILDDIR}/${PROJECT}.pc: ${PROJECTNV}.pc.in config.mk $(call colorecho,GEN,$(shell basename $@)) @mkdir -p ${BUILDDIR} $(QUIET)sed -e 's,@PROJECT@,${PROJECT},' \ -e 's,@VERSION@,${VERSION},' \ -e 's,@INCLUDEDIR@,${INCLUDEDIR},' \ -e 's,@LIBDIR@,${LIBDIR},' \ -e 's,@LIBNOTIFY_PC_NAME@,${LIBNOTIFY_PC_NAME},' \ -e 's,@JSON_PC_NAME@,${JSON_PC_NAME},' \ ${PROJECTNV}.pc.in > $@.tmp $(QUIET)mv $@.tmp $@ # release build ${OBJECTS}: config.mk \ ${PROJECTNV}/version.h \ .version-checks/GTK \ .version-checks/GLIB ${BUILDDIR_RELEASE}/%.o: %.c $(call colorecho,CC,$<) @mkdir -p ${DEPENDDIR}/$(dir $@) @mkdir -p $(dir $(abspath $@)) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} -o $@ $< \ -MMD -MF ${DEPENDDIR}/$@.dep ${BUILDDIR_RELEASE}/${BINDIR}/lib${PROJECT}.a: ${OBJECTS} $(call colorecho,AR,$@) @mkdir -p ${BUILDDIR_RELEASE}/${BINDIR} $(QUIET)${AR} rcs $@ ${OBJECTS} ${BUILDDIR_RELEASE}/${BINDIR}/lib${PROJECT}.so.${SOVERSION}: ${OBJECTS} $(call colorecho,LD,$@) @mkdir -p ${BUILDDIR_RELEASE}/${BINDIR} $(QUIET)${CC} -Wl,${SONAME_FLAG},lib${PROJECT}.so.${SOMAJOR} \ ${SHARED_FLAG} ${LDFLAGS} -o $@ ${OBJECTS} ${LIBS} ${PROJECT}: static shared ${PROJECTNV}: ${PROJECT} static: ${BUILDDIR_RELEASE}/${BINDIR}/lib${PROJECT}.a shared: ${BUILDDIR_RELEASE}/${BINDIR}/lib${PROJECT}.so.${SOVERSION} release: ${PROJECT} # debug build ${OBJECT_DEBUG}: config.mk \ ${PROJECTNV}/version.h \ .version-checks/GTK \ .version-checks/GLIB ${BUILDDIR_DEBUG}/%.o: %.c $(call colorecho,CC,$<) @mkdir -p ${DEPENDDIR}/$(dir $@) @mkdir -p $(dir $(abspath $@)) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} ${DFLAGS} -o $@ $< \ -MMD -MF ${DEPENDDIR}/$@.dep ${BUILDDIR_DEBUG}/${BINDIR}/lib${PROJECT}.a: ${OBJECTS_DEBUG} $(call colorecho,AR,$@) @mkdir -p ${BUILDDIR_DEBUG}/${BINDIR} $(QUIET)${AR} rcs $@ ${OBJECTS_DEBUG} ${BUILDDIR_DEBUG}/${BINDIR}/lib${PROJECT}.so.${SOVERSION}: ${OBJECTS_DEBUG} $(call colorecho,LD,$@) @mkdir -p ${BUILDDIR_DEBUG}/${BINDIR} $(QUIET)${CC} -Wl,${SONAME_FLAG},lib${PROJECT}.so.${SOMAJOR} ${SHARED_FLAG} ${LDFLAGS} -o $@ ${OBJECTS_DEBUG} ${LIBS} ${PROJECT}-debug: \ ${BUILDDIR_DEBUG}/${BINDIR}/lib${PROJECT}.a \ ${BUILDDIR_DEBUG}/${BINDIR}/lib${PROJECT}.so.${SOVERSION} debug: ${PROJECT}-debug # gcov build ${OBJECTS_GCOV}: config.mk \ ${PROJECTNV}/version.h \ .version-checks/GLIB \ .version-checks/GTK ${BUILDDIR_GCOV}/%.o: %.c $(call colorecho,CC,$<) @mkdir -p ${DEPENDDIR}/$(dir $@) @mkdir -p $(dir $(abspath $@)) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} ${GCOV_CFLAGS} \ -o $@ $< -MMD -MF ${DEPENDDIR}/$@.dep ${BUILDDIR_GCOV}/${BINDIR}/lib${PROJECT}.a: ${OBJECTS_GCOV} $(call colorecho,AR,$@) @mkdir -p ${BUILDDIR_GCOV}/${BINDIR} $(QUIET)${AR} rcs $@ ${OBJECTS_GCOV} ${BUILDDIR_GCOV}/${BINDIR}/lib${PROJECT}.so.${SOVERSION}: ${OBJECTS_GCOV} $(call colorecho,LD,$@) @mkdir -p ${BUILDDIR_GCOV}/${BINDIR} $(QUIET)${CC} -Wl,${SONAME_FLAG},lib${PROJECT}.so.${SOMAJOR} ${SHARED_FLAG} \ ${GCOV_LDFLAGS} -o $@ ${OBJECTS_GCOV} ${LIBS} ${PROJECT}-gcov: ${BUILDDIR_GCOV}/${BINDIR}/lib${PROJECT}.a gcov: ${PROJECT}-gcov run-gcov: options gcov $(QUIET)${MAKE} -C tests run-gcov $(call colorecho,LCOV,"Analyse data") $(QUIET)${LCOV_EXEC} ${LCOV_FLAGS} $(call colorecho,LCOV,"Generate report") $(QUIET)${GENHTML_EXEC} ${GENHTML_FLAGS} # clean clean: $(QUIET)rm -rf \ ${BUILDDIR} \ ${DEPENDDIR} \ ${TARFILE} \ ${GCDA} \ ${GCNO} \ $(PROJECT).info \ gcov \ .version-checks \ ${PROJECTNV}/version.h \ ${PROJECTNV}/version.h.tmp \ ${PROJECTNV}/css-definitions.c \ ${PROJECTNV}/css-definitions.c.tmp $(QUIET)$(MAKE) -C tests clean $(QUIET)$(MAKE) -C po clean $(QUIET)$(MAKE) -C doc clean # translations po: $(QUIET)${MAKE} -C po update-po: $(QUIET)${MAKE} -C po update-po # documentation doc: $(QUIET)$(MAKE) -C doc # tests test: ${PROJECT} $(QUIET)$(MAKE) -C tests run test-debug: ${PROJECT}-debug $(QUIET)$(MAKE) -C tests run-debug # create taball dist: $(QUIET)tar -czf $(TARFILE) --exclude=.gitignore \ --transform 's,^,$(PROJECTNV)-$(VERSION)/,' \ `git ls-files` # install install-static: static $(call colorecho,INSTALL,"Install static library") $(QUIET)mkdir -m 755 -p ${DESTDIR}${LIBDIR} $(QUIET)install -m 644 ${BUILDDIR_RELEASE}/${BINDIR}/lib${PROJECT}.a ${DESTDIR}${LIBDIR} install-shared: shared $(call colorecho,INSTALL,"Install shared library") $(QUIET)mkdir -m 755 -p ${DESTDIR}${LIBDIR} $(QUIET)install -m 644 ${BUILDDIR_RELEASE}/${BINDIR}/lib${PROJECT}.so.${SOVERSION} ${DESTDIR}${LIBDIR} $(QUIET)ln -sf lib${PROJECT}.so.${SOVERSION} ${DESTDIR}${LIBDIR}/lib${PROJECT}.so.${SOMAJOR} || \ echo "Failed to create lib${PROJECT}.so.${SOMAJOR}. Please check if it exists and points to the correct version of lib${PROJECT}.so." $(QUIET)ln -sf lib${PROJECT}.so.${SOVERSION} ${DESTDIR}${LIBDIR}/lib${PROJECT}.so || \ echo "Failed to create lib${PROJECT}.so. Please check if it exists and points to the correct version of lib${PROJECT}.so." install-headers: ${PROJECTNV}/version.h ${BUILDDIR}/${PROJECT}.pc $(call colorecho,INSTALL,"Install pkg-config file") $(QUIET)mkdir -m 755 -p ${DESTDIR}${LIBDIR}/pkgconfig $(QUIET)install -m 644 ${BUILDDIR}/${PROJECT}.pc ${DESTDIR}${LIBDIR}/pkgconfig $(call colorecho,INSTALL,"Install header files") $(QUIET)mkdir -m 755 -p ${DESTDIR}${INCLUDEDIR}/girara $(QUIET)install -m 644 ${HEADERS} ${DESTDIR}${INCLUDEDIR}/girara install-po: $(QUIET)${MAKE} -C po install install: install-po install-static install-shared install-headers # uninstall uninstall: uninstall-headers $(call colorecho,UNINSTALL,"Remove library files") $(QUIET)rm -f ${LIBDIR}/lib${PROJECT}.a ${LIBDIR}/lib${PROJECT}.so.${SOVERSION} \ ${LIBDIR}/lib${PROJECT}.so.${SOMAJOR} ${LIBDIR}/lib${PROJECT}.so $(QUIET)${MAKE} -C po uninstall uninstall-headers: $(call colorecho,UNINSTALL,"Remove header files") $(QUIET)rm -rf ${DESTDIR}${INCLUDEDIR}/girara $(call colorecho,UNINSTALL,"Remove pkg-config file") $(QUIET)rm -f ${DESTDIR}${LIBDIR}/pkgconfig/${PROJECT}.pc DEPENDS = ${DEPENDDIRS:^=${DEPENDDIR}/}$(addprefix ${DEPENDDIR}/,${OBJECTS:.o=.o.dep}) -include ${DEPENDS} .PHONY: all options clean debug doc test dist install install-headers uninstall \ uninstall-headers ${PROJECT} ${PROJECT}-debug po update-po \ static shared install-static install-shared girara-0.2.5/README0000644000175000017500000000222512635750323012316 0ustar mockmockgirara - user interface library =============================== girara is a library that implements a user interface that focuses on simplicity and minimalism. It consists of three main components: The view is a widget that represents the actual application (e.g.: a web site or a document). The input bar is used to execute commands of the application, while the status bar notifies the user with current information. It is designed to replace and the enhance the user interface that is used by zathura and jumanji. Requirements ------------ glib (>= 2.28) gtk3 (>= 3.4) intltool libnotify (optional, for notification support) Please note that you need to have a working pkg-config installation and that the Makefile is only compatible with GNU make. If you don't have a working pkg-config installation, please set the GTK_INC and GTK_LIB environment variables. Installation ------------ Run the following command to build and install girara to your system: make install Uninstall --------- To delete girara from your system, type: make uninstall Bugs ---- Please report bugs at http://bugs.pwmt.org or contact us on our mailing list at girara@lists.pwmt.org. girara-0.2.5/colors.mk0000644000175000017500000000151012635750323013264 0ustar mockmock# See LICENSE file for license and copyright information ifeq ($(COLOR),1) # GCC diagnostics colors DIAGNOSTICS_COLOR_AVAILABLE ?= $(shell ($(CC) -fdiagnostics-color=always -E - /dev/null 2>/dev/null && echo 1) || echo 0) ifeq ($(DIAGNOSTICS_COLOR_AVAILABLE),1) CPPFLAGS += -fdiagnostics-color=always endif # colorful output TPUT ?= /usr/bin/tput TPUT_AVAILABLE ?= $(shell ${TPUT} -V 2>/dev/null) ifdef TPUT_AVAILABLE COLOR_NORMAL = `$(TPUT) sgr0` COLOR_ACTION = `$(TPUT) bold``$(TPUT) setaf 3` COLOR_COMMENT = `$(TPUT) bold``$(TPUT) setaf 2` COLOR_BRACKET = `$(TPUT) setaf 4` define colorecho @echo $(COLOR_BRACKET)" ["$(COLOR_ACTION)$1$(COLOR_BRACKET)"] "$(COLOR_COMMENT)$2$(COLOR_BRACKET) $(COLOR_NORMAL) endef else define colorecho @echo " [$1]" $2 endef endif else define colorecho @echo " [$1]" $2 endef endif girara-0.2.5/common.mk0000644000175000017500000000017612512771304013256 0ustar mockmock# See LICENSE file for license and copyright information ifeq "$(VERBOSE)" "0" ECHO=@echo QUIET=@ else ECHO=@\# QUIET= endif girara-0.2.5/config.mk0000644000175000017500000000556312635750332013244 0ustar mockmock# See LICENSE file for license and copyright information GIRARA_VERSION_MAJOR = 0 GIRARA_VERSION_MINOR = 2 GIRARA_VERSION_REV = 5 VERSION = ${GIRARA_VERSION_MAJOR}.${GIRARA_VERSION_MINOR}.${GIRARA_VERSION_REV} # Rules for the SOMAJOR and SOMINOR. # Before a release check perform the following checks against the last release: # * If a function has been removed or the paramaters of a function have changed # bump SOMAJOR and set SOMINOR to 0. # * If any of the exported datastructures have changed in a incompatible way # bump SOMAJOR and set SOMINOR to 0. # * If a function has been added bump SOMINOR. SOMAJOR = 2 SOMINOR = 0 SOVERSION = ${SOMAJOR}.${SOMINOR} # pkg-config binary PKG_CONFIG ?= pkg-config # libnotify WITH_LIBNOTIFY ?= $(shell (${PKG_CONFIG} libnotify --atleast-version=0.7.0 && echo 1) || echo 0) # libjson-c WITH_JSON ?= $(shell (${PKG_CONFIG} json-c --exists && echo 1) || echo 0) # paths PREFIX ?= /usr LIBDIR ?= ${PREFIX}/lib INCLUDEDIR ?= ${PREFIX}/include # locale directory LOCALEDIR ?= ${PREFIX}/share/locale # build directories DEPENDDIR ?= .depend BUILDDIR ?= build BUILDDIR_RELEASE ?= ${BUILDDIR}/release BUILDDIR_DEBUG ?= ${BUILDDIR}/debug BUILDDIR_GCOV ?= ${BUILDDIR}/gcov BINDIR ?= bin # version checks # If you want to disable any of the checks, set *_VERSION_CHECK to 0. # GTK+ GTK_VERSION_CHECK ?= 1 GTK_MIN_VERSION = 3.4 GTK_PKG_CONFIG_NAME = gtk+-3.0 # glib GLIB_VERSION_CHECK ?= 1 GLIB_MIN_VERSION = 2.28 GLIB_PKG_CONFIG_NAME = glib-2.0 # libs GTK_INC ?= $(shell ${PKG_CONFIG} --cflags gtk+-3.0) GTK_LIB ?= $(shell ${PKG_CONFIG} --libs gtk+-3.0) ifneq (${WITH_LIBNOTIFY},0) LIBNOTIFY_INC ?= $(shell ${PKG_CONFIG} --cflags libnotify) LIBNOTIFY_LIB ?= $(shell ${PKG_CONFIG} --libs libnotify) endif ifneq (${WITH_JSON},0) JSON_INC ?= $(shell ${PKG_CONFIG} --cflags json-c) JSON_LIB ?= $(shell ${PKG_CONFIG} --libs json-c) endif INCS = ${GTK_INC} ${LIBNOTIFY_INC} ${JSON_INC} LIBS = ${GTK_LIB} ${LIBNOTIFY_LIB} ${JSON_LIB} -lm # pre-processor flags CPPFLAGS += -D_FILE_OFFSET_BITS=64 # compiler flags CFLAGS += -std=c11 -pedantic -Wall -Wextra -fPIC $(INCS) # linker flags LDFLAGS += -fPIC # debug DFLAGS = -O0 -g # compiler CC ?= gcc # archiver AR ?= ar # strip SFLAGS ?= -s # soname SONAME_FLAG ?= -soname SHARED_FLAG ?= -shared # set to something != 0 if you want verbose build output VERBOSE ?= 0 # gettext package name GETTEXT_PACKAGE ?= lib${PROJECT}-${SOMAJOR} # msgfmt MSGFMT ?= msgfmt # gcov & lcov GCOV_CFLAGS=-fprofile-arcs -ftest-coverage GCOV_LDFLAGS=-fprofile-arcs LCOV_OUTPUT=gcov LCOV_EXEC=lcov LCOV_FLAGS=--base-directory . --directory ${BUILDDIR_GCOV} --capture --rc \ lcov_branch_coverage=1 --output-file ${BUILDDIR_GCOV}/$(PROJECT).info GENHTML_EXEC=genhtml GENHTML_FLAGS=--rc lcov_branch_coverage=1 --output-directory ${LCOV_OUTPUT} ${BUILDDIR_GCOV}/$(PROJECT).info # colors COLOR ?= 1 # dist TARFILE = ${PROJECTNV}-${VERSION}.tar.gz girara-0.2.5/data/girara.css_t0000644000175000017500000000472712635750323014662 0ustar mockmock/* No resize grip */ #@session@ { -GtkWindow-resize-grip-height: 0; -GtkWindow-resize-grip-width: 0; } /* Hide scrollbars from GtkScrolledWindow */ #@session@ GtkScrolledWindow GtkScrollbar:insensitive { -GtkRange-slider-width: 0; -GtkRange-trough-border: 0; } #@session@ GtkScrolledWindow GtkScrollbar { background-color: @scrollbar-bg@; } #@session@ GtkScrolledWindow GtkScrollbar.slider { background-color: @scrollbar-fg@; } #@session@ * { color: @default-fg@; background-color: @default-bg@; background-image: none; font: @font@; } /* Inputbar */ #@session@ GtkEntry.inputbar { background-color: @inputbar-bg@; } #@session@ .inputbar { color: @inputbar-fg@; background-color: @inputbar-bg@; } /* Completion entries and groups */ #@session@ .completion, .completion-box { color: @completion-fg@; background-color: @completion-bg@; } #@session@ .completion { padding: 1px; } #@session@ .completion:selected { color: @completion-highlight-fg@; background-color: @completion-highlight-bg@; } #@session@ .completion-group { color: @completion-group-fg@; background-color: @completion-group-bg@; padding: 2px 4px; } /* Statusbar */ #@session@ .statusbar { color: @statusbar-fg@; background-color: @statusbar-bg@; } /* Tabbar */ #@session@ .tab { color: @tabbar-fg@; background-color: @tabbar-bg@; } #@session@ GtkLabel.tab { padding: 4px; } #@session@ .tab:selected { color: @tabbar-focus-fg@; background-color: @tabbar-focus-bg@; } /* Notification area */ #@session@ .notification { color: @notification-fg@; background-color: @notification-bg@; } #@session@ .notification-error { color: @notification-error-fg@; background-color: @notification-error-bg@; } #@session@ .notification-warning { color: @notification-warning-fg@; background-color: @notification-warning-bg@; } /* Padding of the bottom box */ #@session@ .bottom_box { border-style: none; margin: 0px; padding: @bottombox-padding1@px @bottombox-padding2@px @bottombox-padding3@px @bottombox-padding4@px; } #@session@ GtkScrolledWindow .undershoot.top, #@session@ GtkScrolledWindow .undershoot.top:backdrop, #@session@ GtkScrolledWindow .undershoot.bottom, #@session@ GtkScrolledWindow .undershoot.bottom:backdrop, #@session@ GtkScrolledWindow .undershoot.left, #@session@ GtkScrolledWindow .undershoot.left:backdrop, #@session@ GtkScrolledWindow .undershoot.right, #@session@ GtkScrolledWindow .undershoot.right:backdrop { background-color: transparent; } girara-0.2.5/doc/Doxyfile0000644000175000017500000000125312513025726013706 0ustar mockmock# See LICENSE file for license and copyright information # General information PROJECT_NAME = girara OUTPUT_DIRECTORY = build OUTPUT_LANGUAGE = English TAB_SIZE = 2 EXTRACT_ALL = YES OPTIMIZE_OUTPUT_FOR_C = YES DOXYFILE_ENCODING = UTF-8 TYPEDEF_HIDES_STRUCT = YES # Warning and progress messages QUIET = YES WARNINGS = YES WARN_IF_UNDOCUMENTED = YES # Input files INPUT = ../ EXCLUDE = ../tests FILE_PATTERNS = *.h RECURSIVE = YES # Output files GENERATE_HTML = YES GENERATE_LATEX = NO GENERATE_RTF = NO GENERATE_XML = NO SOURCE_BROWSER = YES # HTML settings HTML_TIMESTAMP = NO girara-0.2.5/doc/Makefile0000644000175000017500000000073012513025726013637 0ustar mockmock# See LICENSE file for license and copyright information include ../config.mk include ../common.mk include ../colors.mk include config.mk DOXYGEN_SOURCES=$(wildcard ../*.h) Doxyfile all: html html: ${DOXYGEN_BUILDDIR}/html/index.html clean: $(call colorecho,RM,doc/${DOXYGEN_BUILDDIR}) $(QUIET)rm -rf ${DOXYGEN_BUILDDIR} ${DOXYGEN_BUILDDIR}/html/index.html: $(call colorecho,DOC,"Build HTML documentation") $(QUIET)${DOXYGEN_BIN} Doxyfile .PHONY: clean html all girara-0.2.5/doc/config.mk0000644000175000017500000000016012513025726013772 0ustar mockmock# See LICENSE file for license and copyright information DOXYGEN_BIN ?= doxygen DOXYGEN_BUILDDIR ?= build girara-0.2.5/girara.pc.in0000644000175000017500000000047512635750323013641 0ustar mockmockproject=@PROJECT@ version=@VERSION@ includedir=@INCLUDEDIR@ libdir=@LIBDIR@ GTK_VERSION=3 Name: ${project} Description: User interface libray Version: ${version} URL: http://pwmt.org/projects/girara Cflags: -I${includedir} Libs: -L${libdir} -l${project} Requires.private: gtk+-3.0 @LIBNOTIFY_PC_NAME@ @JSON_PC_NAME@ girara-0.2.5/girara/callbacks.c0000644000175000017500000004356712513025726015001 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "callbacks.h" #include "datastructures.h" #include "session.h" #include "shortcuts.h" #include "input-history.h" #include #include #include "internal.h" static const guint ALL_ACCELS_MASK = GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK; static const guint MOUSE_MASK = GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK | GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK | GDK_BUTTON4_MASK | GDK_BUTTON5_MASK; static bool clean_mask(guint hardware_keycode, GdkModifierType state, gint group, guint* clean, guint* keyval) { GdkModifierType consumed = 0; if ((gdk_keymap_translate_keyboard_state( gdk_keymap_get_default(), hardware_keycode, state, group, keyval, NULL, NULL, &consumed) ) == FALSE) { return false; } if (clean != NULL) { *clean = state & ~consumed & ALL_ACCELS_MASK; } /* numpad numbers */ switch (*keyval) { case GDK_KEY_KP_0: *keyval = GDK_KEY_0; break; case GDK_KEY_KP_1: *keyval = GDK_KEY_1; break; case GDK_KEY_KP_2: *keyval = GDK_KEY_2; break; case GDK_KEY_KP_3: *keyval = GDK_KEY_3; break; case GDK_KEY_KP_4: *keyval = GDK_KEY_4; break; case GDK_KEY_KP_5: *keyval = GDK_KEY_5; break; case GDK_KEY_KP_6: *keyval = GDK_KEY_6; break; case GDK_KEY_KP_7: *keyval = GDK_KEY_7; break; case GDK_KEY_KP_8: *keyval = GDK_KEY_8; break; case GDK_KEY_KP_9: *keyval = GDK_KEY_9; break; } return true; } /* callback implementation */ bool girara_callback_view_key_press_event(GtkWidget* UNUSED(widget), GdkEventKey* event, girara_session_t* session) { g_return_val_if_fail(session != NULL, FALSE); guint clean = 0; guint keyval = 0; if (clean_mask(event->hardware_keycode, event->state, event->group, &clean, &keyval) == false) { return false; } /* prepare event */ GIRARA_LIST_FOREACH(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcut) if (session->buffer.command != NULL) { break; } if ( keyval == shortcut->key && (clean == shortcut->mask || (shortcut->key >= 0x21 && shortcut->key <= 0x7E && clean == GDK_SHIFT_MASK)) && (session->modes.current_mode == shortcut->mode || shortcut->mode == 0) && shortcut->function != NULL ) { int t = (session->buffer.n > 0) ? session->buffer.n : 1; for (int i = 0; i < t; i++) { if (shortcut->function(session, &(shortcut->argument), NULL, session->buffer.n) == false) { break; } } if (session->global.buffer != NULL) { g_string_free(session->global.buffer, TRUE); session->global.buffer = NULL; } session->buffer.n = 0; if (session->events.buffer_changed != NULL) { session->events.buffer_changed(session); } girara_list_iterator_free(iter); return TRUE; } GIRARA_LIST_FOREACH_END(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcut); /* update buffer */ if (keyval >= 0x21 && keyval <= 0x7E) { /* overall buffer */ if (session->global.buffer == NULL) { session->global.buffer = g_string_new(""); } session->global.buffer = g_string_append_c(session->global.buffer, keyval); if (session->buffer.command == NULL && keyval >= 0x30 && keyval <= 0x39) { if (((session->buffer.n * 10) + (keyval - '0')) < INT_MAX) { session->buffer.n = (session->buffer.n * 10) + (keyval - '0'); } } else { if (session->buffer.command == NULL) { session->buffer.command = g_string_new(""); } session->buffer.command = g_string_append_c(session->buffer.command, keyval); } if (session->events.buffer_changed != NULL) { session->events.buffer_changed(session); } } /* check for buffer command */ if (session->buffer.command != NULL) { bool matching_command = FALSE; GIRARA_LIST_FOREACH(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcut) if (shortcut->buffered_command != NULL) { /* buffer could match a command */ if (!strncmp(session->buffer.command->str, shortcut->buffered_command, session->buffer.command->len)) { /* command matches buffer exactly */ if (!strcmp(session->buffer.command->str, shortcut->buffered_command) && (session->modes.current_mode == shortcut->mode || shortcut->mode == 0)) { g_string_free(session->buffer.command, TRUE); g_string_free(session->global.buffer, TRUE); session->buffer.command = NULL; session->global.buffer = NULL; if (session->events.buffer_changed != NULL) { session->events.buffer_changed(session); } int t = (session->buffer.n > 0) ? session->buffer.n : 1; for (int i = 0; i < t; i++) { if (shortcut->function(session, &(shortcut->argument), NULL, session->buffer.n) == false) { break; } } session->buffer.n = 0; girara_list_iterator_free(iter); return TRUE; } matching_command = TRUE; } } GIRARA_LIST_FOREACH_END(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcut); /* free buffer if buffer will never match a command */ if (matching_command == false) { g_string_free(session->buffer.command, TRUE); g_string_free(session->global.buffer, TRUE); session->buffer.command = NULL; session->global.buffer = NULL; session->buffer.n = 0; if (session->events.buffer_changed != NULL) { session->events.buffer_changed(session); } } } return FALSE; } bool girara_callback_view_button_press_event(GtkWidget* UNUSED(widget), GdkEventButton* button, girara_session_t* session) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(button != NULL, false); /* prepare girara event */ girara_event_t event; switch (button->type) { case GDK_BUTTON_PRESS: event.type = GIRARA_EVENT_BUTTON_PRESS; break; case GDK_2BUTTON_PRESS: event.type = GIRARA_EVENT_2BUTTON_PRESS; break; case GDK_3BUTTON_PRESS: event.type = GIRARA_EVENT_3BUTTON_PRESS; break; default: /* do not handle unknown events */ event.type = GIRARA_EVENT_OTHER; break; } event.x = button->x; event.y = button->y; const guint state = button->state & MOUSE_MASK; /* search registered mouse events */ GIRARA_LIST_FOREACH(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event) if (mouse_event->function != NULL && button->button == mouse_event->button && state == mouse_event->mask && mouse_event->event_type == event.type && (session->modes.current_mode == mouse_event->mode || mouse_event->mode == 0) ) { mouse_event->function(session, &(mouse_event->argument), &event, session->buffer.n); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event); return false; } bool girara_callback_view_button_release_event(GtkWidget* UNUSED(widget), GdkEventButton* button, girara_session_t* session) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(button != NULL, false); /* prepare girara event */ girara_event_t event; event.type = GIRARA_EVENT_BUTTON_RELEASE; event.x = button->x; event.y = button->y; const guint state = button->state & MOUSE_MASK; /* search registered mouse events */ GIRARA_LIST_FOREACH(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event) if (mouse_event->function != NULL && button->button == mouse_event->button && state == mouse_event->mask && mouse_event->event_type == GIRARA_EVENT_BUTTON_RELEASE && (session->modes.current_mode == mouse_event->mode || mouse_event->mode == 0) ) { mouse_event->function(session, &(mouse_event->argument), &event, session->buffer.n); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event); return false; } bool girara_callback_view_button_motion_notify_event(GtkWidget* UNUSED(widget), GdkEventMotion* button, girara_session_t* session) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(button != NULL, false); /* prepare girara event */ girara_event_t event = { .type = GIRARA_EVENT_MOTION_NOTIFY, .x = button->x, .y = button->y }; const guint state = button->state & MOUSE_MASK; /* search registered mouse events */ GIRARA_LIST_FOREACH(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event) if (mouse_event->function != NULL && state == mouse_event->mask && mouse_event->event_type == event.type && (session->modes.current_mode == mouse_event->mode || mouse_event->mode == 0) ) { mouse_event->function(session, &(mouse_event->argument), &event, session->buffer.n); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event); return false; } bool girara_callback_view_scroll_event(GtkWidget* UNUSED(widget), GdkEventScroll* scroll, girara_session_t* session) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(scroll != NULL, false); /* prepare girara event */ girara_event_t event; event.x = scroll->x; event.y = scroll->y; switch (scroll->direction) { case GDK_SCROLL_UP: event.type = GIRARA_EVENT_SCROLL_UP; break; case GDK_SCROLL_DOWN: event.type = GIRARA_EVENT_SCROLL_DOWN; break; case GDK_SCROLL_LEFT: event.type = GIRARA_EVENT_SCROLL_LEFT; break; case GDK_SCROLL_RIGHT: event.type = GIRARA_EVENT_SCROLL_RIGHT; break; case GDK_SCROLL_SMOOTH: event.type = GIRARA_EVENT_SCROLL_BIDIRECTIONAL; /* We abuse x and y here. We really need more fields in girara_event_t. */ gdk_event_get_scroll_deltas((GdkEvent*)scroll, &event.x, &event.y); break; default: return false; } const guint state = scroll->state & MOUSE_MASK; /* search registered mouse events */ /* TODO: Filter correct event */ GIRARA_LIST_FOREACH(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event) if (mouse_event->function != NULL && state == mouse_event->mask && mouse_event->event_type == event.type && (session->modes.current_mode == mouse_event->mode || mouse_event->mode == 0) ) { mouse_event->function(session, &(mouse_event->argument), &event, session->buffer.n); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.mouse_events, girara_mouse_event_t*, iter, mouse_event); return false; } bool girara_callback_inputbar_activate(GtkEntry* entry, girara_session_t* session) { g_return_val_if_fail(session != NULL, FALSE); /* a custom handler has been installed (e.g. by girara_dialog) */ if (session->signals.inputbar_custom_activate != NULL) { bool return_value = session->signals.inputbar_custom_activate(entry, session->signals.inputbar_custom_data); /* disconnect custom handler */ session->signals.inputbar_custom_activate = NULL; session->signals.inputbar_custom_key_press_event = NULL; session->signals.inputbar_custom_data = NULL; if (session->gtk.inputbar_dialog != NULL && session->gtk.inputbar_entry != NULL) { gtk_label_set_markup(session->gtk.inputbar_dialog, ""); gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar_dialog)); if (session->global.autohide_inputbar == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); } gtk_entry_set_visibility(session->gtk.inputbar_entry, TRUE); girara_isc_abort(session, NULL, NULL, 0); return true; } return return_value; } gchar *input = gtk_editable_get_chars(GTK_EDITABLE(entry), 1, -1); if (input == NULL) { girara_isc_abort(session, NULL, NULL, 0); return false; } if (strlen(input) == 0) { g_free(input); girara_isc_abort(session, NULL, NULL, 0); return false; } /* append to command history */ const char* command = gtk_entry_get_text(entry); girara_input_history_append(session->command_history, command); /* parse input */ gchar** argv = NULL; gint argc = 0; if (g_shell_parse_argv(input, &argc, &argv, NULL) == FALSE) { g_free(input); return false; } gchar *cmd = argv[0]; /* special commands */ char *identifier_s = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, 1); if (identifier_s == NULL) { g_free(input); g_strfreev(argv); return false; } char identifier = identifier_s[0]; g_free(identifier_s); GIRARA_LIST_FOREACH(session->bindings.special_commands, girara_special_command_t*, iter, special_command) if (special_command->identifier == identifier) { if (special_command->always != true) { special_command->function(session, input, &(special_command->argument)); } g_free(input); g_strfreev(argv); girara_isc_abort(session, NULL, NULL, 0); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.special_commands, girara_special_command_t*, iter, special_command); /* search commands */ GIRARA_LIST_FOREACH(session->bindings.commands, girara_command_t*, iter, command) if ((g_strcmp0(cmd, command->command) == 0) || (g_strcmp0(cmd, command->abbr) == 0)) { girara_list_t* argument_list = girara_list_new(); if (argument_list == NULL) { g_free(input); g_strfreev(argv); girara_list_iterator_free(iter); return false; } girara_list_set_free_function(argument_list, g_free); for(int i = 1; i < argc; i++) { char* argument = g_strdup(argv[i]); girara_list_append(argument_list, (void*) argument); } command->function(session, argument_list); girara_list_free(argument_list); g_free(input); g_strfreev(argv); girara_isc_abort(session, NULL, NULL, 0); if (session->global.autohide_inputbar == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); } gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar_dialog)); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.commands, girara_command_t*, iter, command); /* check for unknown command event handler */ if (session->events.unknown_command != NULL) { if (session->events.unknown_command(session, input) == true) { g_strfreev(argv); g_free(input); girara_isc_abort(session, NULL, NULL, 0); if (session->global.autohide_inputbar == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); } gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar_dialog)); return true; } } /* unhandled command */ girara_notify(session, GIRARA_ERROR, _("Not a valid command: %s"), cmd); g_strfreev(argv); girara_isc_abort(session, NULL, NULL, 0); return false; } bool girara_callback_inputbar_key_press_event(GtkWidget* entry, GdkEventKey* event, girara_session_t* session) { g_return_val_if_fail(session != NULL, false); /* a custom handler has been installed (e.g. by girara_dialog) */ bool custom_ret = false; if (session->signals.inputbar_custom_key_press_event != NULL) { custom_ret = session->signals.inputbar_custom_key_press_event(entry, event, session->signals.inputbar_custom_data); if (custom_ret == true) { girara_isc_abort(session, NULL, NULL, 0); if (session->global.autohide_inputbar == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); } gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar_dialog)); } } guint keyval = 0; guint clean = 0; if (clean_mask(event->hardware_keycode, event->state, event->group, &clean, &keyval) == false) { return false; } if (custom_ret == false) { GIRARA_LIST_FOREACH(session->bindings.inputbar_shortcuts, girara_inputbar_shortcut_t*, iter, inputbar_shortcut) if (inputbar_shortcut->key == keyval && inputbar_shortcut->mask == clean) { if (inputbar_shortcut->function != NULL) { inputbar_shortcut->function(session, &(inputbar_shortcut->argument), NULL, 0); } girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.inputbar_shortcuts, girara_inputbar_shortcut_t*, iter, inputbar_shortcut); } if ((session->gtk.results != NULL) && (gtk_widget_get_visible(GTK_WIDGET(session->gtk.results)) == TRUE) && (keyval == GDK_KEY_space)) { gtk_widget_hide(GTK_WIDGET(session->gtk.results)); } return custom_ret; } bool girara_callback_inputbar_changed_event(GtkEditable* entry, girara_session_t* session) { g_return_val_if_fail(session != NULL, false); /* special commands */ char *identifier_s = gtk_editable_get_chars(entry, 0, 1); if (identifier_s == NULL) { return false; } char identifier = identifier_s[0]; g_free(identifier_s); GIRARA_LIST_FOREACH(session->bindings.special_commands, girara_special_command_t*, iter, special_command) if ((special_command->identifier == identifier) && (special_command->always == true)) { gchar *input = gtk_editable_get_chars(GTK_EDITABLE(entry), 1, -1); special_command->function(session, input, &(special_command->argument)); g_free(input); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.special_commands, girara_special_command_t*, iter, special_command); return false; } girara-0.2.5/girara/callbacks.h0000644000175000017500000000740012513025726014770 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_CALLBACKS_H #define GIRARA_CALLBACKS_H #include "types.h" #include /** * Callback definition for an inputbar key press event handler * * @param widget The widget * @param event Event * @param data Custom data * @return true if no error occured */ typedef bool (*girara_callback_inputbar_key_press_event_t)(GtkWidget* widget, GdkEventKey* event, void* data); /** * Callback definition for an inputbar key press event handler * * @param entry The inputbar * @param data Custom data * @return true if no error occured */ typedef bool (*girara_callback_inputbar_activate_t)(GtkEntry* entry, void* data); /** * Default callback for key press events in the view area * * @param widget The used widget * @param event The occured event * @param session The used girara session * @return TRUE No error occured * @return FALSE An error occured */ bool girara_callback_view_key_press_event(GtkWidget* widget, GdkEventKey* event, girara_session_t* session); /** * Default callback when a button (typically a mouse button) has been pressed * * @param widget The used widget * @param button The button that triggered the event * @param session The used girara session * @return true to stop other handlers from being invoked for the event. * @return false to propagate the event further. */ bool girara_callback_view_button_press_event(GtkWidget* widget, GdkEventButton* button, girara_session_t* session); /** * Default callback when a button (typically a mouse button) has been released * * @param widget The used widget * @param button The button that triggered the event * @param session The used girara session * @return true to stop other handlers from being invoked for the event. * @return false to propagate the event further. */ bool girara_callback_view_button_release_event(GtkWidget* widget, GdkEventButton* button, girara_session_t* session); /** * Default callback when the pointer moves over the widget * * @param widget The used widget * @param button The event motion that triggered the event * @param session The used girara session * @return true to stop other handlers from being invoked for the event. * @return false to propagate the event further. */ bool girara_callback_view_button_motion_notify_event(GtkWidget* widget, GdkEventMotion* button, girara_session_t* session); /** * Default callback then a scroll event is triggered by the view * * @param widget The widget * @param event The event motion * @param session The girara session * @return true to stop other handlers from being invoked for the event. * @return false to propagate the event further. */ bool girara_callback_view_scroll_event(GtkWidget* widget, GdkEventScroll* event, girara_session_t* session); /** * Default callback if the inputbar gets activated * * @param entry The inputbar entry * @param session The used girara session * @return TRUE No error occured * @return FALSE An error occured */ bool girara_callback_inputbar_activate(GtkEntry* entry, girara_session_t* session); /** * Default callback if an key in the input bar gets pressed * * @param widget The used widget * @param event The occured event * @param session The used girara session * @return TRUE No error occured * @return FALSE An error occured */ bool girara_callback_inputbar_key_press_event(GtkWidget* widget, GdkEventKey* event, girara_session_t* session); /** * Default callback if the text of the input bar has changed * * @param widget The used widget * @param session The used girara session * @return TRUE No error occured * @return FALSE An error occured */ bool girara_callback_inputbar_changed_event(GtkEditable* widget, girara_session_t* session); #endif girara-0.2.5/girara/commands.c0000644000175000017500000004630312635750323014655 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include #include "commands.h" #include "datastructures.h" #include "session.h" #include "internal.h" #include "utils.h" #include "settings.h" #include "shortcuts.h" /* default commands implementation */ bool girara_cmd_map_unmap(girara_session_t* session, girara_list_t* argument_list, bool unmap) { typedef struct gdk_keyboard_button_s { char* identifier; int keyval; } gdk_keyboard_button_t; static const gdk_keyboard_button_t gdk_keyboard_buttons[] = { {"BackSpace", GDK_KEY_BackSpace}, {"CapsLock", GDK_KEY_Caps_Lock}, {"Down", GDK_KEY_Down}, {"Esc", GDK_KEY_Escape}, {"F10", GDK_KEY_F10}, {"F11", GDK_KEY_F11}, {"F12", GDK_KEY_F12}, {"F1", GDK_KEY_F1}, {"F2", GDK_KEY_F2}, {"F3", GDK_KEY_F3}, {"F4", GDK_KEY_F4}, {"F5", GDK_KEY_F5}, {"F6", GDK_KEY_F6}, {"F7", GDK_KEY_F7}, {"F8", GDK_KEY_F8}, {"F9", GDK_KEY_F9}, {"Left", GDK_KEY_Left}, {"PageDown", GDK_KEY_Page_Down}, {"PageUp", GDK_KEY_Page_Up}, {"Home", GDK_KEY_Home}, {"End", GDK_KEY_End}, {"Return", GDK_KEY_Return}, {"Right", GDK_KEY_Right}, {"Space", GDK_KEY_space}, {"Super", GDK_KEY_Super_L}, {"Tab", GDK_KEY_Tab}, {"ShiftTab", GDK_KEY_ISO_Left_Tab}, {"Up", GDK_KEY_Up}, {"Print", GDK_KEY_Print}, {"Home", GDK_KEY_Home} }; typedef struct gdk_mouse_button_s { char* identifier; int button; } gdk_mouse_button_t; static const gdk_mouse_button_t gdk_mouse_buttons[] = { {"Button1", GIRARA_MOUSE_BUTTON1}, {"Button2", GIRARA_MOUSE_BUTTON2}, {"Button3", GIRARA_MOUSE_BUTTON3}, {"Button4", GIRARA_MOUSE_BUTTON4}, {"Button5", GIRARA_MOUSE_BUTTON5}, {"Button6", GIRARA_MOUSE_BUTTON6}, {"Button7", GIRARA_MOUSE_BUTTON7}, {"Button8", GIRARA_MOUSE_BUTTON8}, {"Button9", GIRARA_MOUSE_BUTTON9} }; typedef struct event_type_s { char* identifier; int event; } event_type_t; static const event_type_t event_types[] = { {"motion", GIRARA_EVENT_MOTION_NOTIFY}, {"scroll_up", GIRARA_EVENT_SCROLL_UP}, {"scroll_down", GIRARA_EVENT_SCROLL_DOWN}, {"scroll_left", GIRARA_EVENT_SCROLL_LEFT}, {"scroll_right", GIRARA_EVENT_SCROLL_RIGHT} }; typedef struct mouse_event_s { char* identifier; int event; } mouse_event_t; static const mouse_event_t mouse_events[] = { {"button-pressed", GIRARA_EVENT_BUTTON_PRESS}, {"2-button-pressed", GIRARA_EVENT_2BUTTON_PRESS}, {"3-button-pressed", GIRARA_EVENT_2BUTTON_PRESS}, {"button-released", GIRARA_EVENT_BUTTON_RELEASE} }; const size_t number_of_arguments = girara_list_size(argument_list); unsigned int limit = (unmap == true) ? 1 : 2; if (number_of_arguments < limit) { girara_warning("Invalid number of arguments passed: %zu instead of at least %u", number_of_arguments, limit); girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments passed: %zu instead of at least %u"), number_of_arguments, limit); return false; } int shortcut_mask = 0; int shortcut_key = 0; int shortcut_mouse_button = 0; girara_mode_t shortcut_mode = session->modes.normal; char* shortcut_argument_data = NULL; int shortcut_argument_n = 0; char* shortcut_buffer_command = NULL; girara_event_type_t event_type = GIRARA_EVENT_BUTTON_PRESS; girara_shortcut_function_t shortcut_function = NULL; bool mouse_event = false; size_t current_command = 0; char* tmp = girara_list_nth(argument_list, current_command); size_t tmp_length = strlen(tmp); /* Check first argument for mode */ bool is_mode = false; if (tmp_length >= 3 && tmp[0] == '[' && tmp[tmp_length - 1] == ']') { char* tmp_inner = g_strndup(tmp + 1, tmp_length - 2); GIRARA_LIST_FOREACH(session->modes.identifiers, girara_mode_string_t*, iter, mode) if (!g_strcmp0(tmp_inner, mode->name)) { shortcut_mode = mode->index; is_mode = true; break; } GIRARA_LIST_FOREACH_END(session->modes.identifiers, girara_mode_string_t*, iter, mode); if (is_mode == false) { girara_warning("Unregistered mode specified: %s", tmp_inner); girara_notify(session, GIRARA_ERROR, _("Unregistered mode specified: %s"), tmp_inner); g_free(tmp_inner); return false; } g_free(tmp_inner); } if (is_mode == true) { tmp = girara_list_nth(argument_list, ++current_command); tmp_length = strlen(tmp); } /* Check for multi key shortcut */ if (tmp_length >= 3 && tmp[0] == '<' && tmp[tmp_length - 1] == '>') { tmp = g_strndup(tmp + 1, tmp_length - 2); tmp_length = strlen(tmp); /* Multi key shortcut */ if (strchr(tmp, '-') != NULL && tmp[1] == '-' && tmp_length > 2) { switch (tmp[0]) { case 'S': shortcut_mask = GDK_SHIFT_MASK; break; case 'A': case 'M': shortcut_mask = GDK_MOD1_MASK; break; case 'C': shortcut_mask = GDK_CONTROL_MASK; break; default: girara_warning("Invalid modifier in %s", tmp); girara_notify(session, GIRARA_ERROR, _("Invalid modifier in %s"), tmp); g_free(tmp); return false; } /* Single key */ if (tmp_length == 3) { shortcut_key = tmp[2]; /* Possible special key */ } else { bool found = false; for (unsigned int i = 0; i < LENGTH(gdk_keyboard_buttons); i++) { if (g_strcmp0(tmp + 2, gdk_keyboard_buttons[i].identifier) == 0) { shortcut_key = gdk_keyboard_buttons[i].keyval; found = true; break; } } for (unsigned int i = 0; i < LENGTH(gdk_mouse_buttons); i++) { if (!g_strcmp0(tmp + 2, gdk_mouse_buttons[i].identifier)) { shortcut_mouse_button = gdk_mouse_buttons[i].button; mouse_event = true; found = true; break; } } for (unsigned int i = 0; i < LENGTH(event_types); i++) { if (!g_strcmp0(tmp + 2, event_types[i].identifier)) { event_type = event_types[i].event; mouse_event = true; found = true; break; } } if (found == false) { girara_warning("Invalid special key value or mode: %s", tmp); girara_notify(session, GIRARA_ERROR, _("Invalid special key value for %s"), tmp); g_free(tmp); return false; } } /* Possible special key */ } else { bool found = false; for (unsigned int i = 0; i < LENGTH(gdk_keyboard_buttons); i++) { if (g_strcmp0(tmp, gdk_keyboard_buttons[i].identifier) == 0) { shortcut_key = gdk_keyboard_buttons[i].keyval; found = true; break; } } for (unsigned int i = 0; i < LENGTH(gdk_mouse_buttons); i++) { if (!g_strcmp0(tmp, gdk_mouse_buttons[i].identifier)) { shortcut_mouse_button = gdk_mouse_buttons[i].button; mouse_event = true; found = true; break; } } for (unsigned int i = 0; i < LENGTH(event_types); i++) { if (!g_strcmp0(tmp, event_types[i].identifier)) { event_type = event_types[i].event; mouse_event = true; found = true; break; } } if (found == false) { girara_warning("Invalid special key value or mode: %s", tmp); girara_notify(session, GIRARA_ERROR, _("Invalid special key value or mode %s"), tmp); g_free(tmp); return false; } } g_free(tmp); /* Single key shortcut */ } else if (tmp_length == 1) { shortcut_key = tmp[0]; /* Buffer command */ } else { shortcut_buffer_command = g_strdup(tmp); } /* check for mouse mode */ bool mouse_mode = false; if (unmap == false) { if (++current_command < number_of_arguments) { tmp = girara_list_nth(argument_list, current_command); tmp_length = strlen(tmp); if (tmp_length >= 3 && tmp[0] == '[' && tmp[tmp_length - 1] == ']') { mouse_mode = true; if (mouse_event == false) { girara_warning("Mode passed on non-mouse event: %s", tmp); return false; } char* tmp_inner = g_strndup(tmp + 1, tmp_length - 2); bool found = false; for (unsigned int i = 0; i < LENGTH(mouse_events); i++) { if (!g_strcmp0(tmp_inner, mouse_events[i].identifier)) { event_type = mouse_events[i].event; found = true; break; } } if (found == false) { girara_warning("Invalid mouse event mode has been passed: %s", tmp_inner); g_free(tmp_inner); return false; } g_free(tmp_inner); } } else { girara_warning("Invalid number of arguments passed"); return false; } } if (unmap == false) { limit = (mouse_mode == true) ? 3 : 2; if (number_of_arguments < limit) { girara_warning("Invalid number of arguments passed: %zu instead of at least %u", number_of_arguments, limit); girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments passed: %zu instead of at least %u"), number_of_arguments, limit); return false; } if (mouse_mode == true) { tmp = girara_list_nth(argument_list, ++current_command); } } /* Check for passed shortcut command */ if (unmap == false) { bool found_mapping = false; GIRARA_LIST_FOREACH(session->config.shortcut_mappings, girara_shortcut_mapping_t*, iter, mapping) if (!g_strcmp0(tmp, mapping->identifier)) { shortcut_function = mapping->function; found_mapping = true; break; } GIRARA_LIST_FOREACH_END(session->config.shortcut_mappings, girara_shortcut_mapping_t*, iter, mapping); if (found_mapping == false) { girara_warning("Not a valid shortcut function: %s", tmp); girara_notify(session, GIRARA_ERROR, _("Not a valid shortcut function: %s"), tmp); if (shortcut_buffer_command) { g_free(shortcut_buffer_command); } return false; } } /* Check for passed argument */ if (unmap == false) { if (++current_command < number_of_arguments) { tmp = (char*) girara_list_nth(argument_list, current_command); GIRARA_LIST_FOREACH(session->config.argument_mappings, girara_argument_mapping_t*, iter, mapping) if (!g_strcmp0(tmp, mapping->identifier)) { shortcut_argument_n = mapping->value; break; } GIRARA_LIST_FOREACH_END(session->config.argument_mappings, girara_argument_mapping_t*, iter, mapping); /* If no known argument is passed we save it in the data field */ if (shortcut_argument_n == 0) { shortcut_argument_data = tmp; /* If a known argument is passed and there are still more arguments, * we save the next one in the data field */ } else if (++current_command < number_of_arguments) { tmp = (char*) girara_list_nth(argument_list, current_command); shortcut_argument_data = tmp; } } } if (mouse_event == false) { if (unmap == true) { girara_shortcut_remove(session, shortcut_mask, shortcut_key, shortcut_buffer_command, shortcut_mode); } else { girara_shortcut_add(session, shortcut_mask, shortcut_key, shortcut_buffer_command, shortcut_function, shortcut_mode, shortcut_argument_n, shortcut_argument_data); } } else { if (unmap == true) { girara_mouse_event_remove(session, shortcut_mask, shortcut_mouse_button, shortcut_mode); } else { girara_mouse_event_add(session, shortcut_mask, shortcut_mouse_button, shortcut_function, shortcut_mode, event_type, shortcut_argument_n, shortcut_argument_data); } } if (shortcut_buffer_command) { g_free(shortcut_buffer_command); } return true; } bool girara_cmd_map(girara_session_t* session, girara_list_t* argument_list) { return girara_cmd_map_unmap(session, argument_list, false); } bool girara_cmd_unmap(girara_session_t* session, girara_list_t* argument_list) { return girara_cmd_map_unmap(session, argument_list, true); } bool girara_cmd_quit(girara_session_t* session, girara_list_t* UNUSED(argument_list)) { girara_argument_t arg = { GIRARA_HIDE, NULL }; girara_isc_completion(session, &arg, NULL, 0); gtk_main_quit(); return true; } bool girara_cmd_set(girara_session_t* session, girara_list_t* argument_list) { const size_t number_of_arguments = girara_list_size(argument_list); if (number_of_arguments == 0) { girara_warning("Not enough arguments for :set."); girara_notify(session, GIRARA_ERROR, _("Not enough arguments.")); return false; } if (number_of_arguments > 2) { girara_warning("Too many arguments for :set."); girara_notify(session, GIRARA_ERROR, _("Too many arguments.")); return false; } /* search for existing setting */ char* name = (char*) girara_list_nth(argument_list, 0); if (name == NULL) { return false; } girara_setting_t* setting = girara_setting_find(session, name); if (setting == NULL) { girara_warning("Unknown option: %s", name); girara_notify(session, GIRARA_ERROR, _("Unknown option: %s"), name); return false; } if (number_of_arguments == 1) { /* display setting*/ switch (girara_setting_get_type(setting)) { case BOOLEAN: { /* for compatibility reasons: toogle the setting */ bool value = false; girara_setting_get_value(setting, &value); bool tmp = !value; girara_setting_set_value(session, setting, &tmp); girara_notify(session, GIRARA_INFO, "%s: %s", name, tmp ? _("true") : _("false")); break; } case FLOAT: { float value = 0; girara_setting_get_value(setting, &value); girara_notify(session, GIRARA_INFO, "%s: %f", name, value); break; } case INT: { int value = 0; girara_setting_get_value(setting, &value); girara_notify(session, GIRARA_INFO, "%s: %i", name, value); break; } case STRING: { char* str = NULL; girara_setting_get_value(setting, &str); girara_notify(session, GIRARA_INFO, "%s: %s", name, str ? str : "(NULL)"); g_free(str); break; } default: return false; } } else { char* value = (char*) girara_list_nth(argument_list, 1); if (value == NULL) { girara_warning("No value defined for option: %s", name); girara_notify(session, GIRARA_ERROR, _("No value defined for option: %s"), name); return false; } /* update value */ switch (girara_setting_get_type(setting)) { case BOOLEAN: if (g_strcmp0(value, "false") == 0 || g_strcmp0(value, "0") == 0) { bool b = false; girara_setting_set_value(session, setting, &b); } else if (g_strcmp0(value, "true") == 0 || g_strcmp0(value, "1") == 0) { bool b = true; girara_setting_set_value(session, setting, &b); } else { girara_warning("Unknown value for option: %s", name); girara_notify(session, GIRARA_ERROR, _("Unknown value for option: %s"), name); } break; case FLOAT: { float f = g_ascii_strtod(value, NULL); girara_setting_set_value(session, setting, &f); break; } case INT: { int i = atoi(value); girara_setting_set_value(session, setting, &i); break; } case STRING: girara_setting_set_value(session, setting, value); break; default: return false; } } return true; } bool girara_inputbar_command_add(girara_session_t* session, const char* command, const char* abbreviation, girara_command_function_t function, girara_completion_function_t completion, const char* description) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(command != NULL, false); g_return_val_if_fail(function != NULL, false); /* search for existing binding */ GIRARA_LIST_FOREACH(session->bindings.commands, girara_command_t*, iter, commands_it) if (g_strcmp0(commands_it->command, command) == 0) { g_free(commands_it->abbr); g_free(commands_it->description); commands_it->abbr = abbreviation ? g_strdup(abbreviation) : NULL; commands_it->function = function; commands_it->completion = completion; commands_it->description = description ? g_strdup(description) : NULL; girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.commands, girara_command_t*, iter, commands_it); /* add new inputbar command */ girara_command_t* new_command = g_slice_new(girara_command_t); new_command->command = g_strdup(command); new_command->abbr = abbreviation ? g_strdup(abbreviation) : NULL; new_command->function = function; new_command->completion = completion; new_command->description = description ? g_strdup(description) : NULL; girara_list_append(session->bindings.commands, new_command); return true; } bool girara_special_command_add(girara_session_t* session, char identifier, girara_inputbar_special_function_t function, bool always, int argument_n, void* argument_data) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(function != NULL, false); girara_argument_t argument = {argument_n, argument_data}; /* search for existing special command */ GIRARA_LIST_FOREACH(session->bindings.special_commands, girara_special_command_t*, iter, scommand_it) if (scommand_it->identifier == identifier) { scommand_it->function = function; scommand_it->always = always; scommand_it->argument = argument; girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.special_commands, girara_special_command_t*, iter, scommand_it); /* create new special command */ girara_special_command_t* special_command = g_slice_new(girara_special_command_t); special_command->identifier = identifier; special_command->function = function; special_command->always = always; special_command->argument = argument; girara_list_append(session->bindings.special_commands, special_command); return true; } void girara_special_command_free(girara_special_command_t* special_command) { if (special_command == NULL) { return; } g_slice_free(girara_special_command_t, special_command); } void girara_command_free(girara_command_t* command) { if (command == NULL) { return; } g_free(command->command); g_free(command->abbr); g_free(command->description); g_slice_free(girara_command_t, command); } bool girara_cmd_exec(girara_session_t* session, girara_list_t* argument_list) { if (session == NULL || argument_list == NULL) { return true; } return girara_exec_with_argument_list(session, argument_list); } girara-0.2.5/girara/commands.h0000644000175000017500000000246412513025726014657 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_COMMANDS_H #define GIRARA_COMMANDS_H #include "types.h" /** * Adds an inputbar command * * @param session The used girara session * @param command The name of the command * @param abbreviation The abbreviation of the command * @param function Executed function * @param completion Completion function * @param description Description of the command * @return TRUE No error occured * @return FALSE An error occured */ bool girara_inputbar_command_add(girara_session_t* session, const char* command, const char* abbreviation, girara_command_function_t function, girara_completion_function_t completion, const char* description); /** * Adds a special command * * @param session The used girara session * @param identifier Char identifier * @param function Executed function * @param always If the function should executed on every change of the input * (e.g.: incremental search) * @param argument_n Argument identifier * @param argument_data Argument data * @return TRUE No error occured * @return FALSE An error occured */ bool girara_special_command_add(girara_session_t* session, char identifier, girara_inputbar_special_function_t function, bool always, int argument_n, void* argument_data); #endif girara-0.2.5/girara/completion.c0000644000175000017500000004453212513025726015224 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include #include "completion.h" #include "internal.h" #include "session.h" #include "settings.h" #include "datastructures.h" #include "utils.h" static GtkEventBox* girara_completion_row_create(const char*, const char*, bool); static void girara_completion_row_set_color(girara_session_t*, GtkEventBox*, int); /* completion */ struct girara_internal_completion_entry_s { bool group; /**< The entry is a group */ char* value; /**< Name of the entry */ GtkEventBox* widget; /**< Eventbox widget */ }; /** * Structure of a completion element */ struct girara_completion_element_s { char *value; /**> Name of the completion element */ char *description; /**> Description of the completion element */ }; /** * Structure of a completion group */ struct girara_completion_group_s { char *value; /**> Name of the completion element */ girara_list_t *elements; /**> Elements of the completion group */ }; /** * Structure of a completion object */ struct girara_completion_s { girara_list_t *groups; /**> Containing completion groups */ }; typedef struct girara_internal_completion_entry_s girara_internal_completion_entry_t; static void completion_element_free(girara_completion_element_t* element) { if (element == NULL) { return; } /* free element */ g_free(element->value); g_free(element->description); g_slice_free(girara_completion_element_t, element); } girara_completion_t* girara_completion_init() { girara_completion_t *completion = g_slice_new(girara_completion_t); completion->groups = girara_list_new2( (girara_free_function_t) girara_completion_group_free); return completion; } girara_completion_group_t* girara_completion_group_create(girara_session_t* UNUSED(session), const char* name) { girara_completion_group_t* group = g_slice_new(girara_completion_group_t); group->value = name ? g_strdup(name) : NULL; group->elements = girara_list_new2( (girara_free_function_t) completion_element_free); if (group->elements == NULL) { g_slice_free(girara_completion_group_t, group); return NULL; } return group; } void girara_completion_add_group(girara_completion_t* completion, girara_completion_group_t* group) { g_return_if_fail(completion != NULL); g_return_if_fail(group != NULL); girara_list_append(completion->groups, group); } void girara_completion_group_free(girara_completion_group_t* group) { if (group == NULL) { return; } g_free(group->value); girara_list_free(group->elements); g_slice_free(girara_completion_group_t, group); } void girara_completion_free(girara_completion_t* completion) { g_return_if_fail(completion != NULL); girara_list_free(completion->groups); /* free completion */ g_slice_free(girara_completion_t, completion); } void girara_completion_group_add_element(girara_completion_group_t* group, const char* name, const char* description) { g_return_if_fail(group != NULL); g_return_if_fail(name != NULL); girara_completion_element_t* new_element = g_slice_new(girara_completion_element_t); new_element->value = g_strdup(name); new_element->description = description ? g_strdup(description) : NULL; girara_list_append(group->elements, new_element); } bool girara_isc_completion(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); /* get current text */ gchar *input = gtk_editable_get_chars(GTK_EDITABLE(session->gtk.inputbar_entry), 0, -1); if (input == NULL) { return false; } const size_t input_length = strlen(input); if (input_length == 0 || input[0] != ':') { g_free(input); return false; } gchar** elements = NULL; gint n_parameter = 0; if (input_length > 1) { if (g_shell_parse_argv(input + 1, &n_parameter, &elements, NULL) == FALSE) { g_free(input); return false; } } else { elements = g_try_malloc0(2 * sizeof(char*)); if (elements == NULL) { g_free(input); return false; } elements[0] = g_strdup(""); } if (n_parameter == 1 && input[input_length-1] == ' ') { n_parameter += 1; } g_free(input); /* get current values */ gchar *current_command = (elements[0] != NULL && elements[0][0] != '\0') ? g_strdup(elements[0]) : NULL; gchar *current_parameter = (elements[0] != NULL && elements[1] != NULL) ? g_strdup(elements[1]) : NULL; size_t current_command_length = current_command ? strlen(current_command) : 0; static GList* entries = NULL; static GList* entries_current = NULL; static char *previous_command = NULL; static char *previous_parameter = NULL; static bool command_mode = true; static size_t previous_length = 0; const bool is_single_entry = (1 == g_list_length(entries)); /* delete old list iff * the completion should be hidden * the current command differs from the previous one * the current parameter differs from the previous one * no current command is given * there is only one completion entry */ if ( (argument->n == GIRARA_HIDE) || (current_parameter && previous_parameter && strcmp(current_parameter, previous_parameter)) || (current_command && previous_command && strcmp(current_command, previous_command)) || (input_length != previous_length) || is_single_entry ) { if (session->gtk.results != NULL) { /* destroy elements */ for (GList* element = entries; element; element = g_list_next(element)) { girara_internal_completion_entry_t* entry = (girara_internal_completion_entry_t*) element->data; if (entry != NULL) { gtk_widget_destroy(GTK_WIDGET(entry->widget)); g_free(entry->value); g_slice_free(girara_internal_completion_entry_t, entry); } } g_list_free(entries); entries = NULL; entries_current = NULL; /* delete row box */ gtk_widget_destroy(GTK_WIDGET(session->gtk.results)); session->gtk.results = NULL; } command_mode = true; if (argument->n == GIRARA_HIDE) { g_free(previous_command); previous_command = NULL; g_free(previous_parameter); previous_parameter = NULL; g_strfreev(elements); g_free(current_command); g_free(current_parameter); return false; } } /* create new list iff * there is no current list */ if (session->gtk.results == NULL) { session->gtk.results = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); widget_add_class(GTK_WIDGET(session->gtk.results), "completion-box"); if (session->gtk.results == NULL) { g_free(current_command); g_free(current_parameter); g_strfreev(elements); return false; } if (n_parameter <= 1) { /* based on commands */ command_mode = true; /* create command rows */ GIRARA_LIST_FOREACH(session->bindings.commands, girara_command_t*, iter, command) if (current_command == NULL || (command->command != NULL && !strncmp(current_command, command->command, current_command_length)) || (command->abbr != NULL && !strncmp(current_command, command->abbr, current_command_length)) ) { /* create entry */ girara_internal_completion_entry_t* entry = g_slice_new(girara_internal_completion_entry_t); entry->group = FALSE; entry->value = g_strdup(command->command); entry->widget = girara_completion_row_create(command->command, command->description, FALSE); entries = g_list_append(entries, entry); /* show entry row */ gtk_box_pack_start(session->gtk.results, GTK_WIDGET(entry->widget), FALSE, FALSE, 0); } GIRARA_LIST_FOREACH_END(session->bindings.commands, girara_command_t*, iter, command); } /* based on parameters */ if (n_parameter > 1 || g_list_length(entries) == 1) { /* if only one command exists try to run parameter completion */ if (g_list_length(entries) == 1) { girara_internal_completion_entry_t* entry = g_list_first(entries)->data; /* unset command mode */ command_mode = false; current_command = entry->value; current_command_length = strlen(current_command); /* clear list */ gtk_widget_destroy(GTK_WIDGET(entry->widget)); entries = g_list_remove(entries, g_list_first(entries)->data); g_slice_free(girara_internal_completion_entry_t, entry); } /* search matching command */ girara_command_t* command = NULL; GIRARA_LIST_FOREACH(session->bindings.commands, girara_command_t*, iter, command_it) if ( (current_command != NULL && command_it->command != NULL && !strncmp(current_command, command_it->command, current_command_length)) || (current_command != NULL && command_it->abbr != NULL && !strncmp(current_command, command_it->abbr, current_command_length)) ) { g_free(previous_command); previous_command = g_strdup(command_it->command); command = command_it; break; } GIRARA_LIST_FOREACH_END(session->bindings.commands, girara_command_t*, iter, command_it); if (command == NULL) { g_free(current_command); g_free(current_parameter); g_strfreev(elements); return false; } if (command->completion == NULL) { girara_internal_completion_entry_t* entry = g_slice_new(girara_internal_completion_entry_t); entry->group = FALSE; entry->value = g_strdup(command->command); entry->widget = girara_completion_row_create(command->command, command->description, FALSE); entries = g_list_append(entries, entry); gtk_box_pack_start(session->gtk.results, GTK_WIDGET(entry->widget), FALSE, FALSE, 0); command_mode = true; } else { /* generate completion result * XXX: the last argument should only be current_paramater ... but * therefore the completion functions would need to handle NULL correctly * (see cc_open in zathura). */ girara_completion_t *result = command->completion(session, current_parameter ? current_parameter : ""); if (result == NULL || result->groups == NULL) { g_free(current_command); g_free(current_parameter); g_strfreev(elements); return false; } GIRARA_LIST_FOREACH(result->groups, girara_completion_group_t*, iter, group) /* create group entry */ if (group->value != NULL) { girara_internal_completion_entry_t* entry = g_slice_new(girara_internal_completion_entry_t); entry->group = TRUE; entry->value = g_strdup(group->value); entry->widget = girara_completion_row_create(group->value, NULL, TRUE); entries = g_list_append(entries, entry); gtk_box_pack_start(session->gtk.results, GTK_WIDGET(entry->widget), FALSE, FALSE, 0); } GIRARA_LIST_FOREACH(group->elements, girara_completion_element_t*, iter2, element) girara_internal_completion_entry_t* entry = g_slice_new(girara_internal_completion_entry_t); entry->group = FALSE; entry->value = g_strdup(element->value); entry->widget = girara_completion_row_create(element->value, element->description, FALSE); entries = g_list_append(entries, entry); gtk_box_pack_start(session->gtk.results, GTK_WIDGET(entry->widget), FALSE, FALSE, 0); GIRARA_LIST_FOREACH_END(group->elements, girara_completion_element_t*, iter2, element); GIRARA_LIST_FOREACH_END(result->groups, girara_completion_group_t*, iter, group); girara_completion_free(result); command_mode = false; } } if (entries != NULL) { entries_current = (argument->n == GIRARA_NEXT) ? g_list_last(entries) : entries; gtk_box_pack_start(session->private_data->gtk.bottom_box, GTK_WIDGET(session->gtk.results), FALSE, FALSE, 0); gtk_widget_show(GTK_WIDGET(session->gtk.results)); } } /* update entries */ unsigned int n_elements = g_list_length(entries); if (entries != NULL && n_elements > 0) { if (n_elements > 1) { girara_completion_row_set_color(session, ((girara_internal_completion_entry_t *) entries_current->data)->widget, GIRARA_NORMAL); bool next_group = FALSE; for (unsigned int i = 0; i < n_elements; i++) { if (argument->n == GIRARA_NEXT || argument->n == GIRARA_NEXT_GROUP) { GList* entry = g_list_next(entries_current); if (entry == NULL) { entry = g_list_first(entries); } entries_current = entry; } else if (argument->n == GIRARA_PREVIOUS || argument->n == GIRARA_PREVIOUS_GROUP) { GList* entry = g_list_previous(entries_current); if (entry == NULL) { entry = g_list_last(entries); } entries_current = entry; } if (((girara_internal_completion_entry_t*) entries_current->data)->group) { if (command_mode == false && (argument->n == GIRARA_NEXT_GROUP || argument->n == GIRARA_PREVIOUS_GROUP)) { next_group = TRUE; } continue; } else { if (command_mode == false && (next_group == 0) && (argument->n == GIRARA_NEXT_GROUP || argument->n == GIRARA_PREVIOUS_GROUP)) { continue; } break; } } girara_completion_row_set_color(session, ((girara_internal_completion_entry_t *) entries_current->data)->widget, GIRARA_HIGHLIGHT); /* hide other items */ unsigned int n_completion_items = 15; girara_setting_get(session, "n-completion-items", &n_completion_items); unsigned int uh = ceil( n_completion_items / 2); unsigned int lh = floor(n_completion_items / 2); unsigned int current_item = g_list_position(entries, entries_current); GList* tmpentry = entries; for (unsigned int i = 0; i < n_elements; i++) { if ( (i >= (current_item - lh) && (i <= current_item + uh)) || (i < n_completion_items && current_item < lh) || (i >= (n_elements - n_completion_items) && (current_item >= (n_elements - uh))) ) { gtk_widget_show(GTK_WIDGET(((girara_internal_completion_entry_t*) tmpentry->data)->widget)); } else { gtk_widget_hide(GTK_WIDGET(((girara_internal_completion_entry_t*) tmpentry->data)->widget)); } tmpentry = g_list_next(tmpentry); } } else { gtk_widget_hide(GTK_WIDGET(((girara_internal_completion_entry_t*) (g_list_nth(entries, 0))->data)->widget)); } /* update text */ char* temp; char* escaped_value = girara_escape_string(((girara_internal_completion_entry_t *) entries_current->data)->value); if (command_mode == true) { char* space = (n_elements == 1) ? " " : ""; temp = g_strconcat(":", escaped_value, space, NULL); } else { temp = g_strconcat(":", previous_command, " ", escaped_value, NULL); } gtk_entry_set_text(session->gtk.inputbar_entry, temp); gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), -1); g_free(escaped_value); /* update previous */ g_free(previous_command); g_free(previous_parameter); previous_command = g_strdup((command_mode) ? ((girara_internal_completion_entry_t*) entries_current->data)->value : current_command); previous_parameter = g_strdup((command_mode) ? current_parameter : ((girara_internal_completion_entry_t*) entries_current->data)->value); previous_length = strlen(temp); g_free(temp); } g_free(current_command); g_free(current_parameter); g_strfreev(elements); return false; } static GtkEventBox* girara_completion_row_create(const char* command, const char* description, bool group) { GtkBox *col = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); GtkEventBox *row = GTK_EVENT_BOX(gtk_event_box_new()); GtkLabel *show_command = GTK_LABEL(gtk_label_new(NULL)); GtkLabel *show_description = GTK_LABEL(gtk_label_new(NULL)); gtk_widget_set_halign(GTK_WIDGET(show_command), GTK_ALIGN_START); gtk_widget_set_valign(GTK_WIDGET(show_command), GTK_ALIGN_START); gtk_widget_set_halign(GTK_WIDGET(show_description), GTK_ALIGN_END); gtk_widget_set_valign(GTK_WIDGET(show_description), GTK_ALIGN_START); gtk_label_set_use_markup(show_command, TRUE); gtk_label_set_use_markup(show_description, TRUE); gtk_label_set_ellipsize(show_command, PANGO_ELLIPSIZE_END); gtk_label_set_ellipsize(show_description, PANGO_ELLIPSIZE_END); gchar* c = g_markup_printf_escaped(FORMAT_COMMAND, command ? command : ""); gchar* d = g_markup_printf_escaped(FORMAT_DESCRIPTION, description ? description : ""); gtk_label_set_markup(show_command, c); gtk_label_set_markup(show_description, d); g_free(c); g_free(d); const char* class = group == true ? "completion-group" : "completion"; widget_add_class(GTK_WIDGET(show_command), class); widget_add_class(GTK_WIDGET(show_description), class); widget_add_class(GTK_WIDGET(row), class); widget_add_class(GTK_WIDGET(col), class); gtk_box_pack_start(GTK_BOX(col), GTK_WIDGET(show_command), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(col), GTK_WIDGET(show_description), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(row), GTK_WIDGET(col)); gtk_widget_show_all(GTK_WIDGET(row)); return row; } static void girara_completion_row_set_color(girara_session_t* session, GtkEventBox* row, int mode) { g_return_if_fail(session != NULL); g_return_if_fail(row != NULL); GtkBox* col = GTK_BOX(gtk_bin_get_child(GTK_BIN(row))); GList* items = gtk_container_get_children(GTK_CONTAINER(col)); GtkWidget* cmd = GTK_WIDGET(g_list_nth_data(items, 0)); GtkWidget* desc = GTK_WIDGET(g_list_nth_data(items, 1)); if (mode == GIRARA_HIGHLIGHT) { gtk_widget_set_state_flags(cmd, GTK_STATE_FLAG_SELECTED, false); gtk_widget_set_state_flags(desc, GTK_STATE_FLAG_SELECTED, false); gtk_widget_set_state_flags(GTK_WIDGET(row), GTK_STATE_FLAG_SELECTED, false); } else { gtk_widget_unset_state_flags(cmd, GTK_STATE_FLAG_SELECTED); gtk_widget_unset_state_flags(desc, GTK_STATE_FLAG_SELECTED); gtk_widget_unset_state_flags(GTK_WIDGET(row), GTK_STATE_FLAG_SELECTED); } g_list_free(items); } girara-0.2.5/girara/completion.h0000644000175000017500000000252312513025726015223 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_COMPLETION_H #define GIRARA_COMPLETION_H #include "types.h" /** * Creates an girara completion object * * @return Completion object * @return NULL An error occured */ girara_completion_t* girara_completion_init(); /** * Creates an girara completion group * * @return Completion object * @return NULL An error occured */ girara_completion_group_t* girara_completion_group_create( girara_session_t* session, const char* name); /** * Frees a completion group * * @param group The group */ void girara_completion_group_free(girara_completion_group_t* group); /** * Adds an group to a completion object * * @param completion The completion object * @param group The completion group */ void girara_completion_add_group(girara_completion_t* completion, girara_completion_group_t* group); /** * Frees an completion and all of its groups and elements * * @param completion The completion */ void girara_completion_free(girara_completion_t* completion); /** * Adds an element to a completion group * * @param group The completion group * @param value Value of the entry * @param description Description of the entry */ void girara_completion_group_add_element(girara_completion_group_t* group, const char* value, const char* description); #endif girara-0.2.5/girara/config.c0000644000175000017500000005106212635750323014317 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include #include "config.h" #include "commands.h" #include "datastructures.h" #include "internal.h" #include "session.h" #include "settings.h" #include "shortcuts.h" #include "utils.h" #include "template.h" #define COMMENT_PREFIX "\"#" static void cb_window_icon(girara_session_t* session, const char* UNUSED(name), girara_setting_type_t UNUSED(type), void* value, void* UNUSED(data)) { g_return_if_fail(session != NULL && value != NULL); if (session->gtk.window == NULL) { return; } char* path = girara_fix_path(value); GtkWindow* window = GTK_WINDOW(session->gtk.window); GError* error = NULL; gtk_window_set_icon_from_file(window, path, &error); free(path); if (error == NULL) { return; } girara_debug("Failed to load window icon (file): %s", error->message); girara_debug("Trying name instead."); g_error_free(error); gtk_window_set_icon_name(window, value); } static void cb_font(girara_session_t* session, const char* UNUSED(name), girara_setting_type_t UNUSED(type), void* value, void* UNUSED(data)) { g_return_if_fail(session != NULL && value != NULL); girara_template_set_variable_value(session->private_data->csstemplate, "font", value); } static void cb_guioptions(girara_session_t* session, const char* UNUSED(name), girara_setting_type_t UNUSED(type), void* value, void* UNUSED(data)) { g_return_if_fail(session != NULL && value != NULL); /* set default values */ bool show_commandline = false; bool show_statusbar = false; bool show_hscrollbar = false; bool show_vscrollbar = false; /* evaluate input */ char* input = (char*) value; const size_t input_length = strlen(input); for (size_t i = 0; i < input_length; i++) { switch (input[i]) { /* command line */ case 'c': show_commandline = true; break; /* statusbar */ case 's': show_statusbar = true; break; case 'h': show_hscrollbar = true; break; case 'v': show_vscrollbar = true; break; } } /* apply settings */ if (show_commandline == true) { session->global.autohide_inputbar = false; gtk_widget_show(session->gtk.inputbar); } else { session->global.autohide_inputbar = true; gtk_widget_hide(session->gtk.inputbar); } if (show_statusbar == true) { session->global.hide_statusbar = false; gtk_widget_show(session->gtk.statusbar); } else { session->global.hide_statusbar = true; gtk_widget_hide(session->gtk.statusbar); } GtkWidget* vscrollbar = gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(session->gtk.view)); GtkWidget* hscrollbar = gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(session->gtk.view)); if (vscrollbar != NULL) { if (show_vscrollbar == true) { gtk_widget_unset_state_flags(vscrollbar, GTK_STATE_FLAG_INSENSITIVE); } else { gtk_widget_set_state_flags(vscrollbar, GTK_STATE_FLAG_INSENSITIVE, false); } } if (hscrollbar != NULL) { if (show_hscrollbar == true) { gtk_widget_unset_state_flags(hscrollbar, GTK_STATE_FLAG_INSENSITIVE); } else { gtk_widget_set_state_flags(hscrollbar, GTK_STATE_FLAG_INSENSITIVE, false); } } } static void cb_scrollbars(girara_session_t* session, const char* name, girara_setting_type_t UNUSED(type), void* value, void* UNUSED(data)) { g_return_if_fail(session != NULL && value != NULL); const bool val = *(bool*) value; char* guioptions = NULL; girara_setting_get(session, "guioptions", &guioptions); g_return_if_fail(guioptions != NULL); bool show_hscrollbar = strchr(guioptions, 'h') != NULL; bool show_vscrollbar = strchr(guioptions, 'v') != NULL; if (strcmp(name, "show-scrollbars") == 0) { show_hscrollbar = show_vscrollbar = val; } else if (strcmp(name, "show-h-scrollbar") == 0) { show_hscrollbar = val; } else if (strcmp(name, "show-v-scrollbar") == 0) { show_vscrollbar = val; } const size_t guioptions_len = strlen(guioptions); char* new_guioptions = g_try_malloc0(sizeof(char) * (guioptions_len + 3)); char* iterator = new_guioptions; if (new_guioptions == NULL) { g_free(guioptions); return; } /* copy everything apart from h and v */ for (size_t i = 0; i != guioptions_len; ++i) { if (guioptions[i] != 'h' && guioptions[i] != 'v') { *iterator = guioptions[i]; ++iterator; } } g_free(guioptions); if (show_hscrollbar == true) { *iterator = 'h'; ++iterator; } if (show_vscrollbar == true) { *iterator = 'v'; ++iterator; } girara_setting_set(session, "guioptions", new_guioptions); g_free(new_guioptions); } void girara_config_load_default(girara_session_t* session) { if (session == NULL) { return; } /* values */ int statusbar_h_padding = 8; int statusbar_v_padding = 2; int window_width = 800; int window_height = 600; int n_completion_items = 15; bool show_scrollbars = false; girara_mode_t normal_mode = session->modes.normal; bool use_smooth_scroll = false; /* other values */ session->global.autohide_inputbar = true; /* settings */ girara_setting_add(session, "font", "monospace normal 9", STRING, FALSE, _("Font"), cb_font, NULL); girara_setting_add(session, "default-fg", "#DDDDDD", STRING, TRUE, _("Default foreground color"), NULL, NULL); girara_setting_add(session, "default-bg", "#000000", STRING, TRUE, _("Default background color"), NULL, NULL); girara_setting_add(session, "inputbar-fg", "#9FBC00", STRING, TRUE, _("Inputbar foreground color"), NULL, NULL); girara_setting_add(session, "inputbar-bg", "#131313", STRING, TRUE, _("Inputbar background color"), NULL, NULL); girara_setting_add(session, "statusbar-fg", "#FFFFFF", STRING, TRUE, _("Statusbar foreground color"), NULL, NULL); girara_setting_add(session, "statusbar-bg", "#000000", STRING, TRUE, _("Statsubar background color"), NULL, NULL); girara_setting_add(session, "completion-fg", "#DDDDDD", STRING, TRUE, _("Completion foreground color"), NULL, NULL); girara_setting_add(session, "completion-bg", "#232323", STRING, TRUE, _("Completion background color"), NULL, NULL); girara_setting_add(session, "completion-group-fg", "#DEDEDE", STRING, TRUE, _("Completion group foreground color"), NULL, NULL); girara_setting_add(session, "completion-group-bg", "#000000", STRING, TRUE, _("Completion group background color"), NULL, NULL); girara_setting_add(session, "completion-highlight-fg", "#232323", STRING, TRUE, _("Completion highlight foreground color"), NULL, NULL); girara_setting_add(session, "completion-highlight-bg", "#9FBC00", STRING, TRUE, _("Completion highlight background color"), NULL, NULL); girara_setting_add(session, "notification-error-fg", "#FFFFFF", STRING, TRUE, _("Error notification foreground color"), NULL, NULL); girara_setting_add(session, "notification-error-bg", "#FF1212", STRING, TRUE, _("Error notification background color"), NULL, NULL); girara_setting_add(session, "notification-warning-fg", "#000000", STRING, TRUE, _("Warning notification foreground color"), NULL, NULL); girara_setting_add(session, "notification-warning-bg", "#F3F000", STRING, TRUE, _("Warning notifaction background color"), NULL, NULL); girara_setting_add(session, "notification-fg", "#000000", STRING, TRUE, _("Notification foreground color"), NULL, NULL); girara_setting_add(session, "notification-bg", "#FFFFFF", STRING, TRUE, _("Notification background color"), NULL, NULL); girara_setting_add(session, "scrollbar-fg", "#DDDDDD", STRING, TRUE, _("Scrollbar foreground color"), NULL, NULL); girara_setting_add(session, "scrollbar-bg", "#000000", STRING, TRUE, _("Scrollbar background color"), NULL, NULL); girara_setting_add(session, "tabbar-fg", "#939393", STRING, TRUE, _("Tab bar foreground color"), NULL, NULL); girara_setting_add(session, "tabbar-bg", "#000000", STRING, TRUE, _("Tab bar background color"), NULL, NULL); girara_setting_add(session, "tabbar-focus-fg", "#9FBC00", STRING, TRUE, _("Tab bar foreground color (active)"), NULL, NULL); girara_setting_add(session, "tabbar-focus-bg", "#000000", STRING, TRUE, _("Tab bar background color (active)"), NULL, NULL); girara_setting_add(session, "word-separator", " /.-=&#?", STRING, TRUE, NULL, NULL, NULL); girara_setting_add(session, "window-width", &window_width, INT, TRUE, _("Initial window width"), NULL, NULL); girara_setting_add(session, "window-height", &window_height, INT, TRUE, _("Initial window height"), NULL, NULL); girara_setting_add(session, "statusbar-h-padding", &statusbar_h_padding, INT, TRUE, _("Horizontal padding for the status input and notification bars"), NULL, NULL); girara_setting_add(session, "statusbar-v-padding", &statusbar_v_padding, INT, TRUE, _("Vertical padding for the status input and notification bars"), NULL, NULL); girara_setting_add(session, "n-completion-items", &n_completion_items, INT, TRUE, _("Number of completion items"), NULL, NULL); girara_setting_add(session, "show-scrollbars", &show_scrollbars, BOOLEAN, FALSE, _("Show both the horizontal and vertical scrollbars"), cb_scrollbars, NULL); girara_setting_add(session, "show-h-scrollbar", &show_scrollbars, BOOLEAN, FALSE, _("Show the horizontal scrollbar"), cb_scrollbars, NULL); girara_setting_add(session, "show-v-scrollbar", &show_scrollbars, BOOLEAN, FALSE, _("Show the vertical scrollbar"), cb_scrollbars, NULL); girara_setting_add(session, "window-icon", "", STRING, FALSE, _("Window icon"), cb_window_icon, NULL); girara_setting_add(session, "exec-command", "", STRING, FALSE, _("Command to execute in :exec"), NULL, NULL); girara_setting_add(session, "guioptions", "s", STRING, FALSE, _("Show or hide certain GUI elements"), cb_guioptions, NULL); girara_setting_add(session, "smooth-scroll", &use_smooth_scroll, BOOLEAN, TRUE, _("Enable smooth scrolling and zooming"), NULL, NULL); /* shortcuts */ girara_shortcut_add(session, 0, GDK_KEY_Escape, NULL, girara_sc_abort, normal_mode, 0, NULL); girara_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_bracketleft, NULL, girara_sc_abort, normal_mode, 0, NULL); girara_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_c, NULL, girara_sc_abort, normal_mode, 0, NULL); girara_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_q, NULL, girara_sc_quit, normal_mode, 0, NULL); girara_shortcut_add(session, 0, GDK_KEY_colon, NULL, girara_sc_focus_inputbar, normal_mode, 0, ":"); girara_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_w, NULL, girara_sc_tab_close, normal_mode, 0, NULL); girara_shortcut_add(session, 0, 0, "gt", girara_sc_tab_navigate, normal_mode, GIRARA_NEXT, NULL); girara_shortcut_add(session, 0, 0, "gT", girara_sc_tab_navigate, normal_mode, GIRARA_PREVIOUS, NULL); /* inputbar shortcuts */ girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_j, girara_isc_activate, 0, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_Escape, girara_isc_abort, 0, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_bracketleft, girara_isc_abort, 0, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_c, girara_isc_abort, 0, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_Tab, girara_isc_completion, GIRARA_NEXT, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_Tab, girara_isc_completion, GIRARA_NEXT_GROUP, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_ISO_Left_Tab, girara_isc_completion, GIRARA_PREVIOUS, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_ISO_Left_Tab, girara_isc_completion, GIRARA_PREVIOUS_GROUP, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_BackSpace, girara_isc_string_manipulation, GIRARA_DELETE_LAST_CHAR, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_h, girara_isc_string_manipulation, GIRARA_DELETE_LAST_CHAR, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_u, girara_isc_string_manipulation, GIRARA_DELETE_TO_LINE_START, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_k, girara_isc_string_manipulation, GIRARA_DELETE_TO_LINE_END, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_d, girara_isc_string_manipulation, GIRARA_DELETE_CURR_CHAR, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_w, girara_isc_string_manipulation, GIRARA_DELETE_LAST_WORD, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_f, girara_isc_string_manipulation, GIRARA_NEXT_CHAR, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_b, girara_isc_string_manipulation, GIRARA_PREVIOUS_CHAR, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_Right, girara_isc_string_manipulation, GIRARA_NEXT_CHAR, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_Left, girara_isc_string_manipulation, GIRARA_PREVIOUS_CHAR, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_a, girara_isc_string_manipulation, GIRARA_GOTO_START, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_e, girara_isc_string_manipulation, GIRARA_GOTO_END, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_Up, girara_isc_command_history, GIRARA_PREVIOUS, NULL); girara_inputbar_shortcut_add(session, 0, GDK_KEY_Down, girara_isc_command_history, GIRARA_NEXT, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_p, girara_isc_command_history, GIRARA_PREVIOUS, NULL); girara_inputbar_shortcut_add(session, GDK_CONTROL_MASK, GDK_KEY_n, girara_isc_command_history, GIRARA_NEXT, NULL); /* commands */ girara_inputbar_command_add(session, "exec", NULL, girara_cmd_exec, NULL, _("Execute a command")); girara_inputbar_command_add(session, "map", "m", girara_cmd_map, NULL, _("Map a key sequence")); girara_inputbar_command_add(session, "quit", "q", girara_cmd_quit, NULL, _("Quit the program")); girara_inputbar_command_add(session, "set", "s", girara_cmd_set, girara_cc_set, _("Set an option")); girara_inputbar_command_add(session, "unmap", NULL, girara_cmd_unmap, NULL, _("Unmap a key sequence")); #ifdef WITH_JSON girara_inputbar_command_add(session, "dump", NULL, girara_cmd_dump_config, NULL, _("Dump settings to a file")); #endif /* config handle */ girara_config_handle_add(session, "map", girara_cmd_map); girara_config_handle_add(session, "set", girara_cmd_set); girara_config_handle_add(session, "unmap", girara_cmd_unmap); /* shortcut mappings */ girara_shortcut_mapping_add(session, "focus_inputbar", girara_sc_focus_inputbar); girara_shortcut_mapping_add(session, "quit", girara_sc_quit); girara_shortcut_mapping_add(session, "set", girara_sc_set); girara_shortcut_mapping_add(session, "feedkeys", girara_sc_feedkeys); girara_shortcut_mapping_add(session, "tab_next", girara_sc_tab_navigate_next); girara_shortcut_mapping_add(session, "tab_prev", girara_sc_tab_navigate_prev); } bool girara_config_handle_add(girara_session_t* session, const char* identifier, girara_command_function_t handle) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(identifier != NULL, false); /* search for existing config handle */ GIRARA_LIST_FOREACH(session->config.handles, girara_config_handle_t*, iter, data) if (strcmp(data->identifier, identifier) == 0) { data->handle = handle; girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->config.handles, girara_config_handle_t*, iter, data); /* add new config handle */ girara_config_handle_t* config_handle = g_slice_new(girara_config_handle_t); config_handle->identifier = g_strdup(identifier); config_handle->handle = handle; girara_list_append(session->config.handles, config_handle); return true; } void girara_config_handle_free(girara_config_handle_t* handle) { if (handle == NULL) { return; } g_free(handle->identifier); g_slice_free(girara_config_handle_t, handle); } static bool config_parse(girara_session_t* session, const char* path) { /* open file */ FILE* file = girara_file_open(path, "r"); if (file == NULL) { return false; } /* read lines */ char* line = NULL; unsigned int line_number = 1; while ((line = girara_file_read_line(file)) != NULL) { /* skip empty lines and comments */ if (strlen(line) == 0 || strchr(COMMENT_PREFIX, line[0]) != NULL) { g_free(line); continue; } girara_list_t* argument_list = girara_list_new(); if (argument_list == NULL) { g_free(line); fclose(file); return false; } girara_list_set_free_function(argument_list, g_free); gchar** argv = NULL; gint argc = 0; if (g_shell_parse_argv(line, &argc, &argv, NULL) != FALSE) { for (int i = 1; i < argc; i++) { char* argument = g_strdup(argv[i]); girara_list_append(argument_list, (void*) argument); } } else { girara_list_free(argument_list); fclose(file); g_free(line); return false; } /* include gets a special treatment */ if (strcmp(argv[0], "include") == 0) { if (argc != 2) { girara_warning("Could not process line %d in '%s': usage: include path.", line_number, path); } else { char* newpath = NULL; if (g_path_is_absolute(argv[1]) == TRUE) { newpath = g_strdup(argv[1]); } else { char* basename = g_path_get_dirname(path); char* tmp = g_build_filename(basename, argv[1], NULL); newpath = girara_fix_path(tmp); g_free(tmp); g_free(basename); } if (strcmp(newpath, path) == 0) { girara_warning("Could not process line %d in '%s': trying to include itself.", line_number, path); } else { girara_debug("Loading config file '%s'.", newpath); if (config_parse(session, newpath) == false) { girara_warning("Could not process line %d in '%s': failed to load '%s'.", line_number, path, newpath); } } g_free(newpath); } } else { /* search for config handle */ girara_config_handle_t* handle = NULL; GIRARA_LIST_FOREACH(session->config.handles, girara_config_handle_t*, iter, tmp) handle = tmp; if (strcmp(handle->identifier, argv[0]) == 0) { handle->handle(session, argument_list); break; } else { handle = NULL; } GIRARA_LIST_FOREACH_END(session->config.handles, girara_config_handle_t*, iter, tmp); if (handle == NULL) { girara_warning("Could not process line %d in '%s': Unknown handle '%s'", line_number, path, argv[0]); } } line_number++; girara_list_free(argument_list); g_strfreev(argv); g_free(line); } fclose(file); return true; } void girara_config_parse(girara_session_t* session, const char* path) { config_parse(session, path); } girara-0.2.5/girara/config.h0000644000175000017500000000125312513025726014316 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_CONFIG_H #define GIRARA_CONFIG_H #include "types.h" /** * Parses and evaluates a configuration file * * @param session The used girara session * @param path Path to the configuration file */ void girara_config_parse(girara_session_t* session, const char* path); /** * Adds an additional config handler * * @param session The girara session * @param identifier Identifier of the handle * @param handle Handle * @return true if no error occured, otherwise false */ bool girara_config_handle_add(girara_session_t* session, const char* identifier, girara_command_function_t handle); #endif girara-0.2.5/girara/css-definitions.h0000644000175000017500000000031512513025726016150 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_CSS_DEFINITIONS_H #define GIRARA_CSS_DEFINITIONS_H #include "macros.h" extern const char* CSS_TEMPLATE GIRARA_HIDDEN; #endif girara-0.2.5/girara/datastructures.c0000644000175000017500000002640012513025726016122 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include "datastructures.h" #include "utils.h" struct girara_tree_node_s { girara_free_function_t free; /**> The free function */ GNode* node; /* The node object */ }; typedef struct girara_tree_node_data_s { girara_tree_node_t* node; /**> The node */ void* data; /**> The data */ } girara_tree_node_data_t; struct girara_list_s { girara_free_function_t free; /**> The free function */ girara_compare_function_t cmp; /**> The sort function */ GList* start; /**> List start */ }; struct girara_list_iterator_s { girara_list_t* list; /**> The list */ GList* element; /**> The list object */ }; girara_list_t* girara_list_new(void) { return g_try_malloc0(sizeof(girara_list_t)); } girara_list_t* girara_list_new2(girara_free_function_t gfree) { girara_list_t* list = girara_list_new(); if (list == NULL) { return NULL; } girara_list_set_free_function(list, gfree); return list; } girara_list_t* girara_sorted_list_new(girara_compare_function_t cmp) { girara_list_t* list = girara_list_new(); if (list == NULL) { return NULL; } list->cmp = cmp; return list; } girara_list_t* girara_sorted_list_new2(girara_compare_function_t cmp, girara_free_function_t gfree) { girara_list_t* list = girara_list_new2(gfree); if (list == NULL) { return NULL; } list->cmp = cmp; return list; } void girara_list_set_free_function(girara_list_t* list, girara_free_function_t gfree) { g_return_if_fail(list); list->free = gfree; } void girara_list_clear(girara_list_t* list) { if (list == NULL || list->start == NULL) { return; } if (list->free != NULL) { g_list_free_full(list->start, list->free); } else { g_list_free(list->start); } list->start = NULL; } void girara_list_free(girara_list_t* list) { if (list == NULL) { return; } girara_list_clear(list); g_free(list); } void girara_list_append(girara_list_t* list, void* data) { g_return_if_fail(list != NULL); if (list->cmp != NULL) { list->start = g_list_insert_sorted(list->start, data, list->cmp); } else { list->start = g_list_append(list->start, data); } } void girara_list_prepend(girara_list_t* list, void* data) { g_return_if_fail(list != NULL); if (list->cmp != NULL) { girara_list_append(list, data); } else { list->start = g_list_prepend(list->start, data); } } void girara_list_remove(girara_list_t* list, void* data) { g_return_if_fail(list != NULL); if (list->start == NULL) { return; } GList* tmp = g_list_find(list->start, data); if (tmp == NULL) { return; } if (list->free != NULL) { (list->free)(tmp->data); } list->start = g_list_delete_link(list->start, tmp); } void* girara_list_nth(girara_list_t* list, size_t n) { g_return_val_if_fail(list != NULL, NULL); g_return_val_if_fail(list->start != NULL && (n < g_list_length(list->start)), NULL); GList* tmp = g_list_nth(list->start, n); g_return_val_if_fail(tmp != NULL, NULL); return tmp->data; } bool girara_list_contains(girara_list_t* list, void* data) { g_return_val_if_fail(list != NULL, false); if (!list->start) { return false; } GList* tmp = g_list_find(list->start, data); if (tmp == NULL) { return false; } return true; } void* girara_list_find(girara_list_t* list, girara_compare_function_t compare, const void* data) { g_return_val_if_fail(list != NULL && compare != NULL, NULL); if (list->start == NULL) { return NULL; } GList* element = g_list_find_custom(list->start, data, compare); if (element == NULL) { return NULL; } return element->data; } girara_list_iterator_t* girara_list_iterator(girara_list_t* list) { g_return_val_if_fail(list != NULL, NULL); if (list->start == NULL) { return NULL; } girara_list_iterator_t* iter = g_try_malloc0(sizeof(girara_list_iterator_t)); if (iter == NULL) { return NULL; } iter->list = list; iter->element = list->start; return iter; } girara_list_iterator_t* girara_list_iterator_copy(girara_list_iterator_t* iter) { g_return_val_if_fail(iter != NULL, NULL); girara_list_iterator_t* iter2 = g_try_malloc0(sizeof(girara_list_iterator_t)); if (iter2 == NULL) { return NULL; } iter2->list = iter->list; iter2->element = iter->element; return iter2; } girara_list_iterator_t* girara_list_iterator_next(girara_list_iterator_t* iter) { if (girara_list_iterator_is_valid(iter) == false) { return NULL; } iter->element = g_list_next(iter->element); if (iter->element == NULL) { return NULL; } return iter; } bool girara_list_iterator_has_next(girara_list_iterator_t* iter) { if (girara_list_iterator_is_valid(iter) == false) { return false; } return g_list_next(iter->element); } girara_list_iterator_t* girara_list_iterator_previous(girara_list_iterator_t* iter) { if (girara_list_iterator_is_valid(iter) == false) { return NULL; } iter->element = g_list_previous(iter->element); if (iter->element == NULL) { return NULL; } return iter; } bool girara_list_iterator_has_previous(girara_list_iterator_t* iter) { if (girara_list_iterator_is_valid(iter) == false) { return false; } return g_list_previous(iter->element); } void girara_list_iterator_remove(girara_list_iterator_t* iter) { if (girara_list_iterator_is_valid(iter) == false) { return; } GList* el = iter->element; if (iter->list != NULL && iter->list->free != NULL) { (iter->list->free)(iter->element->data); } iter->element = el->next; iter->list->start = g_list_delete_link(iter->list->start, el); } bool girara_list_iterator_is_valid(girara_list_iterator_t* iter) { return iter != NULL && iter->element != NULL; } void* girara_list_iterator_data(girara_list_iterator_t* iter) { g_return_val_if_fail(girara_list_iterator_is_valid(iter), NULL); return iter->element->data; } void girara_list_iterator_set(girara_list_iterator_t* iter, void *data) { g_return_if_fail(girara_list_iterator_is_valid(iter)); g_return_if_fail(iter->list->cmp == NULL); if (iter->list->free != NULL) { (*iter->list->free)(iter->element->data); } iter->element->data = data; } void girara_list_iterator_free(girara_list_iterator_t* iter) { if (iter == NULL) { return; } g_free(iter); } size_t girara_list_size(girara_list_t* list) { g_return_val_if_fail(list, 0); if (list->start == NULL) { return 0; } return g_list_length(list->start); } ssize_t girara_list_position(girara_list_t* list, void* data) { g_return_val_if_fail(list != NULL, -1); if (list->start == NULL) { return -1; } size_t pos = 0; GIRARA_LIST_FOREACH(list, void*, iter, tmp) if (tmp == data) { girara_list_iterator_free(iter); return pos; } ++pos; GIRARA_LIST_FOREACH_END(list, void*, iter, tmp); return -1; } void girara_list_sort(girara_list_t* list, girara_compare_function_t compare) { g_return_if_fail(list != NULL); if (list->start == NULL || compare == NULL) { return; } list->start = g_list_sort(list->start, compare); } void girara_list_foreach(girara_list_t* list, girara_list_callback_t callback, void* data) { g_return_if_fail(list && list->start && callback); g_list_foreach(list->start, callback, data); } girara_list_t* girara_list_merge(girara_list_t* list, girara_list_t* other) { if (list == NULL) { return other; } if (other == NULL) { return list; } if (list->free != other->free) { girara_warning("girara_list_merge: merging lists with different free functions!"); } other->free = NULL; GIRARA_LIST_FOREACH(other, void*, iter, data) girara_list_append(list, data); GIRARA_LIST_FOREACH_END(other, void*, iter, data); return list; } girara_tree_node_t* girara_node_new(void* data) { girara_tree_node_t* node = g_try_malloc0(sizeof(girara_tree_node_t)); if (node == NULL) { return NULL; } girara_tree_node_data_t* nodedata = g_try_malloc0(sizeof(girara_tree_node_data_t)); if (nodedata == NULL) { g_free(node); return NULL; } nodedata->data = data; nodedata->node = node; node->node = g_node_new(nodedata); if (node->node == NULL) { g_free(node); g_free(nodedata); return NULL; } return node; } void girara_node_set_free_function(girara_tree_node_t* node, girara_free_function_t gfree) { g_return_if_fail(node); node->free = gfree; } void girara_node_free(girara_tree_node_t* node) { if (node == NULL) { return; } g_return_if_fail(node->node); girara_tree_node_data_t* nodedata = (girara_tree_node_data_t*) node->node->data; g_return_if_fail(nodedata); if (node->free != NULL) { (*node->free)(nodedata->data); } g_free(nodedata); GNode* childnode = node->node->children; while (childnode != NULL) { girara_tree_node_data_t* nodedata = (girara_tree_node_data_t*) childnode->data; girara_node_free(nodedata->node); childnode = childnode->next; } g_node_destroy(node->node); g_free(node); } void girara_node_append(girara_tree_node_t* parent, girara_tree_node_t* child) { g_return_if_fail(parent && child); g_node_append(parent->node, child->node); } girara_tree_node_t* girara_node_append_data(girara_tree_node_t* parent, void* data) { g_return_val_if_fail(parent, NULL); girara_tree_node_t* child = girara_node_new(data); g_return_val_if_fail(child, NULL); child->free = parent->free; girara_node_append(parent, child); return child; } girara_tree_node_t* girara_node_get_parent(girara_tree_node_t* node) { g_return_val_if_fail(node && node->node, NULL); if (node->node->parent == NULL) { return NULL; } girara_tree_node_data_t* nodedata = (girara_tree_node_data_t*) node->node->parent->data; g_return_val_if_fail(nodedata, NULL); return nodedata->node; } girara_tree_node_t* girara_node_get_root(girara_tree_node_t* node) { g_return_val_if_fail(node && node->node, NULL); if (node->node->parent == NULL) { return node; } GNode* root = g_node_get_root(node->node); g_return_val_if_fail(root, NULL); girara_tree_node_data_t* nodedata = (girara_tree_node_data_t*) root->data; g_return_val_if_fail(nodedata, NULL); return nodedata->node; } girara_list_t* girara_node_get_children(girara_tree_node_t* node) { g_return_val_if_fail(node, NULL); girara_list_t* list = girara_list_new(); g_return_val_if_fail(list, NULL); GNode* childnode = node->node->children; while (childnode != NULL) { girara_tree_node_data_t* nodedata = (girara_tree_node_data_t*) childnode->data; girara_list_append(list, nodedata->node); childnode = childnode->next; } return list; } size_t girara_node_get_num_children(girara_tree_node_t* node) { g_return_val_if_fail(node && node->node, 0); return g_node_n_children(node->node); } void* girara_node_get_data(girara_tree_node_t* node) { g_return_val_if_fail(node && node->node, NULL); girara_tree_node_data_t* nodedata = (girara_tree_node_data_t*) node->node->data; g_return_val_if_fail(nodedata, NULL); return nodedata->data; } void girara_node_set_data(girara_tree_node_t* node, void* data) { g_return_if_fail(node && node->node); girara_tree_node_data_t* nodedata = (girara_tree_node_data_t*) node->node->data; g_return_if_fail(nodedata); if (node->free != NULL) { (*node->free)(nodedata->data); } nodedata->data = data; } girara-0.2.5/girara/datastructures.h0000644000175000017500000002153512513025726016133 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_DATASTRUCTURES_H #define GIRARA_DATASTRUCTURES_H #include #include #include #include "types.h" /** * Create a new list. * * @return The girara list object or NULL if an error occured */ girara_list_t* girara_list_new(void); /** * Create a new list. * * @param gfree Pointer to the free function * @return The girara list object or NULL if an error occured. */ girara_list_t* girara_list_new2(girara_free_function_t gfree); /** * Create a new (sorted) list. * * @param cmp Pointer to the compare function. * @return The girara list object or NULL if an error occured. */ girara_list_t* girara_sorted_list_new(girara_compare_function_t cmp); /** * Create a new (sorted) list. * * @param cmp Pointer to the compare function. * @param gfree Pointer to the free function * @return The girara list object or NULL if an error occured. */ girara_list_t* girara_sorted_list_new2(girara_compare_function_t cmp, girara_free_function_t gfree); /** * Set the function which should be called if the stored data should be freed. * * @param list The girara list object * @param gfree Pointer to the free function */ void girara_list_set_free_function(girara_list_t* list, girara_free_function_t gfree); /** * Remove all elements from a list. * * @param list The girara list object */ void girara_list_clear(girara_list_t* list); /** * Destroy list. * * @param list The girara list object */ void girara_list_free(girara_list_t* list); /** * Append an element to the list. * * @param list The girara list object * @param data The element */ void girara_list_append(girara_list_t* list, void* data); /** * Prepend an element to the list. * * @param list The girara list object * @param data The element */ void girara_list_prepend(girara_list_t* list, void* data); /** * Remove an element of the list * * @param list The girara list object * @param data The element */ void girara_list_remove(girara_list_t* list, void* data); /** * Returns nth entry * * @param list The girara list object * @param n Index of the entry * @return The nth element or NULL if an error occured */ void* girara_list_nth(girara_list_t* list, size_t n); /** * Checks if the list contains the given element * * @param list The girara list object * @param data The element * @return true if the list contains the element */ bool girara_list_contains(girara_list_t* list, void* data); /** * Get size of the list. * * @param list The girara list object * @return The size of the list */ size_t girara_list_size(girara_list_t* list); /** * Returns the position of the element in the list * * @param list The girara list object * @param data The element * @return The position or -1 if the data is not found */ ssize_t girara_list_position(girara_list_t* list, void* data); /** * Sort a list * * @param list The list to sort * @param compare compare function */ void girara_list_sort(girara_list_t* list, girara_compare_function_t compare); /** * Find an element * * @param list The list * @param compare compare function * @param data data passed as the second argument to the compare function * @return the element if found or NULL */ void* girara_list_find(girara_list_t* list, girara_compare_function_t compare, const void* data); /** * Create an iterator pointing at the start of list. * * @param list The girara list object * @return The list iterator or NULL if an error occured */ girara_list_iterator_t* girara_list_iterator(girara_list_t* list); /** * Create an iterator pointing to the same element as iter. * * @param iter The girara list iterator to be copied * @return The list iterator or NULL if an error occured */ girara_list_iterator_t* girara_list_iterator_copy(girara_list_iterator_t* iter); /** * Move iterator to next element. * * @param iter The list iterator * @return The moved iterator or NULL if an error occured */ girara_list_iterator_t* girara_list_iterator_next(girara_list_iterator_t* iter); /** * Check if iterator has next element. * * @param iter The list iterator * @return true if iterator has a next element, false otherwise */ bool girara_list_iterator_has_next(girara_list_iterator_t* iter); /** * Move iterator to previous element. * * @param iter The list iterator * @return The moved iterator or NULL if an error occured */ girara_list_iterator_t* girara_list_iterator_previous(girara_list_iterator_t* iter); /** * Check if iterator has previous element. * * @param iter The list iterator * @return true if iterator has a previous element, false otherwise */ bool girara_list_iterator_has_previous(girara_list_iterator_t* iter); /** * Remove element pointed by the iterator, and updates the iterator * to the next element * * @param iter The list iterator */ void girara_list_iterator_remove(girara_list_iterator_t* iter); /** * Check if iterator is valid * * @param iter The list iterator * @return true if iterator is valid, false otherwise */ bool girara_list_iterator_is_valid(girara_list_iterator_t* iter); /** * Get data from the element pointed to by the iterator. * * @param iter The list iterator * @return The data of the current element */ void* girara_list_iterator_data(girara_list_iterator_t* iter); /** * Set data from the element pointed to by the iterator. * * @param iter The list iterator * @param data Sets the list iterator to a specific element */ void girara_list_iterator_set(girara_list_iterator_t* iter, void *data); /** * Destroy the iterator. * * @param iter The list iterator */ void girara_list_iterator_free(girara_list_iterator_t* iter); /** * Call function for each element in the list. * * @param list The list * @param callback The function to call. * @param data Passed to the callback as second argument. */ void girara_list_foreach(girara_list_t* list, girara_list_callback_t callback, void* data); #define GIRARA_LIST_FOREACH(list, type, iter, data) \ do { \ girara_list_iterator_t* iter = girara_list_iterator(list); \ while (girara_list_iterator_is_valid(iter)) { \ type data = (type)girara_list_iterator_data(iter); #define GIRARA_LIST_FOREACH_END(list, type, iter, data) \ girara_list_iterator_next(iter); \ } \ girara_list_iterator_free(iter); \ } while(0) /** * Merge a list into another one. Both lists need to have the same free * function. If other has a source free function set it will be set to NULL as * the elements then belong to list. * @param list the target list * @param other the source list * @returns list with the elements from other. */ girara_list_t* girara_list_merge(girara_list_t* list, girara_list_t* other); /** * Create a new node. * * @param data Data of the new node * @return A girara node object or NULL if an error occured */ girara_tree_node_t* girara_node_new(void* data); /** * Set the function which should be called if the stored data should be freed. * * @param node The girara node object * @param gfree Pointer to the free function */ void girara_node_set_free_function(girara_tree_node_t* node, girara_free_function_t gfree); /** * Free a node. This will remove the node from its' parent and will destroy all * its' children. * * @param node The girara node object */ void girara_node_free(girara_tree_node_t* node); /** * Append a node to another node. * * @param parent The parent node * @param child The child node */ void girara_node_append(girara_tree_node_t* parent, girara_tree_node_t* child); /** * Append data as new node to another node. * * @param parent The parent node * @param data The data of the node * @return The node object or NULL if an error occured */ girara_tree_node_t* girara_node_append_data(girara_tree_node_t* parent, void* data); /** * Get parent node. * * @param node The girara node object * @return The parent node or NULL if an error occured or no parent exists */ girara_tree_node_t* girara_node_get_parent(girara_tree_node_t* node); /** * Get root node. * * @param node The girara node object * @return The root node or NULL if an error occured */ girara_tree_node_t* girara_node_get_root(girara_tree_node_t* node); /** * Get list of children. * * @param node The girara node object * @return List object containing all child nodes or NULL if an error occured */ girara_list_t* girara_node_get_children(girara_tree_node_t* node); /** * Get number of children. * * @param node The girara node object * @return The number of child nodes */ size_t girara_node_get_num_children(girara_tree_node_t* node); /** * Get data. * * @param node The girara node object * @return The data of the node */ void* girara_node_get_data(girara_tree_node_t* node); /** * Set data. * * @param node The girara node object * @param data The new data of the object */ void girara_node_set_data(girara_tree_node_t* node, void* data); #endif girara-0.2.5/girara/debug.c0000644000175000017500000000165312615357510014140 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "utils.h" #include static girara_debug_level_t debug_level = GIRARA_DEBUG; void _girara_debug(const char* function, int line, girara_debug_level_t level, const char* format, ...) { if (level < debug_level) { return; } switch (level) { case GIRARA_WARNING: fprintf(stderr, "warning: "); break; case GIRARA_ERROR: fprintf(stderr, "error: "); break; case GIRARA_INFO: fprintf(stderr, "info: "); break; case GIRARA_DEBUG: fprintf(stderr, "debug: (%s:%d) ", function, line); break; default: return; } va_list ap; va_start(ap, format); vfprintf(stderr, format, ap); va_end(ap); fprintf(stderr, "\n"); } girara_debug_level_t girara_get_debug_level() { return debug_level; } void girara_set_debug_level(girara_debug_level_t level) { debug_level = level; } girara-0.2.5/girara/entry.c0000644000175000017500000000316612513025726014212 0ustar mockmock#include "entry.h" #include G_DEFINE_TYPE(GiraraEntry, girara_entry, GTK_TYPE_ENTRY) static void girara_entry_paste_primary(GiraraEntry* self); enum { PASTE_PRIMARY, LAST_SIGNAL }; static guint signals[LAST_SIGNAL] = { 0 }; static void girara_entry_class_init(GiraraEntryClass* klass) { klass->paste_primary = girara_entry_paste_primary; signals[PASTE_PRIMARY] = g_signal_new("paste-primary", GIRARA_TYPE_ENTRY, G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(GiraraEntryClass, paste_primary), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 0); GtkBindingSet* binding_set = gtk_binding_set_by_class(klass); gtk_binding_entry_add_signal(binding_set, GDK_KEY_Insert, GDK_SHIFT_MASK, "paste-primary", 0); } static void girara_entry_init(GiraraEntry* GIRARA_UNUSED(self)) { } GiraraEntry* girara_entry_new(void) { GObject* ret = g_object_new(GIRARA_TYPE_ENTRY, NULL); if (ret == NULL) { return NULL; } return GIRARA_ENTRY(ret); } static void girara_entry_paste_primary(GiraraEntry* self) { GValue editable = G_VALUE_INIT; g_value_init(&editable, G_TYPE_BOOLEAN); g_object_get_property(G_OBJECT(self), "editable", &editable); if (g_value_get_boolean(&editable) == true) { gchar* text = gtk_clipboard_wait_for_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY)); if (text != NULL) { int pos = gtk_editable_get_position(GTK_EDITABLE(self)); gtk_editable_insert_text(GTK_EDITABLE(self), text, -1, &pos); gtk_editable_set_position(GTK_EDITABLE(self), pos); } } else { gtk_widget_error_bell(GTK_WIDGET(self)); } } girara-0.2.5/girara/entry.h0000644000175000017500000000220012513025726014203 0ustar mockmock#ifndef GIRARA_ENTRY_H #define GIRARA_ENTRY_H #include #include "macros.h" /* * Type macros. */ #define GIRARA_TYPE_ENTRY \ (girara_entry_get_type()) #define GIRARA_ENTRY(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj), GIRARA_TYPE_ENTRY, GiraraEntry)) #define GIRARA_IS_ENTRY(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GIRARA_TYPE_ENTRY)) #define GIRARA_ENTRY_CLASS(klass) \ (G_TYPE_CHECK_CLASS_CAST((klass), GIRARA_TYPE_ENTRY, GiraraEntryClass)) #define GIRARA_IS_ENTRY_CLASS(klass) \ (G_TYPE_CHECK_CLASS_TYPE((klass), GIRARA_TYPE_ENTRY)) #define GIRARA_ENTRY_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS((obj), GIRARA_TYPE_ENTRY, GiraraEntryClass)) typedef struct girara_entry_s GiraraEntry; typedef struct girara_entry_class_s GiraraEntryClass; struct girara_entry_s { /* Parent instance structure */ GtkEntry parent_instance; /* instance members */ }; struct girara_entry_class_s { /* Parent class structure */ GtkEntryClass parent_class; /* class members */ void (*paste_primary)(GiraraEntry*); }; GType girara_entry_get_type(void) GIRARA_HIDDEN; GiraraEntry* girara_entry_new(void) GIRARA_HIDDEN; #endif girara-0.2.5/girara/girara.h0000644000175000017500000000061212513025726014314 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_H #define GIRARA_H #include "types.h" #include "session.h" #include "utils.h" #include "datastructures.h" #include "settings.h" #include "completion.h" #include "tabs.h" #include "config.h" #include "statusbar.h" #include "shortcuts.h" #include "commands.h" #include "callbacks.h" #include "input-history.h" #endif girara-0.2.5/girara/input-history-io.c0000644000175000017500000000131312513025726016304 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "input-history.h" #include "macros.h" G_DEFINE_INTERFACE(GiraraInputHistoryIO, girara_input_history_io, G_TYPE_OBJECT) static void girara_input_history_io_default_init(GiraraInputHistoryIOInterface* GIRARA_UNUSED(iface)) { } void girara_input_history_io_append(GiraraInputHistoryIO* io, const char* input) { g_return_if_fail(GIRARA_IS_INPUT_HISTORY_IO(io) == true); GIRARA_INPUT_HISTORY_IO_GET_INTERFACE(io)->append(io, input); } girara_list_t* girara_input_history_io_read(GiraraInputHistoryIO* io) { g_return_val_if_fail(GIRARA_IS_INPUT_HISTORY_IO(io) == true, NULL); return GIRARA_INPUT_HISTORY_IO_GET_INTERFACE(io)->read(io); } girara-0.2.5/girara/input-history.c0000644000175000017500000002133412513025726015704 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "input-history.h" #include "datastructures.h" G_DEFINE_TYPE(GiraraInputHistory, girara_input_history, G_TYPE_OBJECT) /** * Private data of the settings manager */ typedef struct ih_private_s { girara_list_t* history; /**< List of stored inputs */ bool reset; /**< Show history starting from the most recent command */ size_t current; size_t current_match; GiraraInputHistoryIO* io; char* command_line; } ih_private_t; #define GIRARA_INPUT_HISTORY_GET_PRIVATE(obj) \ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIRARA_TYPE_INPUT_HISTORY, \ ih_private_t)) /* Methods */ static void ih_dispose(GObject* object); static void ih_finalize(GObject* object); static void ih_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec); static void ih_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec); static void ih_append(GiraraInputHistory* history, const char* input); static girara_list_t* ih_list(GiraraInputHistory* history); static const char* ih_next(GiraraInputHistory* history, const char* current_input); static const char* ih_previous(GiraraInputHistory* history, const char* current_input); static void ih_reset(GiraraInputHistory* history); /* Properties */ enum { PROP_0, PROP_IO }; /* Class init */ static void girara_input_history_class_init(GiraraInputHistoryClass* class) { /* add private members */ g_type_class_add_private(class, sizeof(ih_private_t)); /* overwrite methods */ GObjectClass* object_class = G_OBJECT_CLASS(class); object_class->dispose = ih_dispose; object_class->finalize = ih_finalize; object_class->set_property = ih_set_property; object_class->get_property = ih_get_property; class->append = ih_append; class->list = ih_list; class->next = ih_next; class->previous = ih_previous; class->reset = ih_reset; /* properties */ g_object_class_install_property(object_class, PROP_IO, g_param_spec_object("io", "history reader/writer", "GiraraInputHistoryIO object used to read and write history", girara_input_history_io_get_type(), G_PARAM_WRITABLE | G_PARAM_READABLE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); } /* Object init */ static void girara_input_history_init(GiraraInputHistory* history) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(history); priv->history = girara_list_new2((girara_free_function_t) g_free); priv->reset = true; priv->io = NULL; } /* GObject dispose */ static void ih_dispose(GObject* object) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(object); g_clear_object(&priv->io); G_OBJECT_CLASS(girara_input_history_parent_class)->dispose(object); } /* GObject finalize */ static void ih_finalize(GObject* object) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(object); girara_list_free(priv->history); g_free(priv->command_line); G_OBJECT_CLASS(girara_input_history_parent_class)->finalize(object); } /* GObject set_property */ static void ih_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(object); switch (prop_id) { case PROP_IO: { if (priv->io != NULL) { g_object_unref(priv->io); } gpointer* tmp = g_value_dup_object(value); if (tmp != NULL) { priv->io = GIRARA_INPUT_HISTORY_IO(tmp); } else { priv->io = NULL; } girara_input_history_reset(GIRARA_INPUT_HISTORY(object)); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } } /* GObject get_property */ static void ih_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(object); switch (prop_id) { case PROP_IO: g_value_set_object(value, priv->io); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } } /* Object new */ GiraraInputHistory* girara_input_history_new(GiraraInputHistoryIO* io) { return GIRARA_INPUT_HISTORY(g_object_new(GIRARA_TYPE_INPUT_HISTORY, "io", io, NULL)); } /* Method implementions */ static void ih_append(GiraraInputHistory* history, const char* input) { if (input == NULL) { return; } girara_list_t* list = girara_input_history_list(history); if (list == NULL) { return; } void* data = NULL; while ((data = girara_list_find(list, (girara_compare_function_t) g_strcmp0, data)) != NULL) { girara_list_remove(list, data); } girara_list_append(list, g_strdup(input)); ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(history); if (priv->io != NULL) { girara_input_history_io_append(priv->io, input); } /* begin from the last command when navigating through history */ girara_input_history_reset(history); } static girara_list_t* ih_list(GiraraInputHistory* history) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(history); return priv->history; } static const char* find_next(GiraraInputHistory* history, const char* current_input, bool next) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(history); girara_list_t* list = girara_input_history_list(history); if (list == NULL) { return NULL; } size_t length = girara_list_size(list); if (length == 0) { return NULL; } if (priv->reset == true) { priv->current = length; priv->current_match = priv->current; } /* Before moving into the history, save the current command-line. */ if (priv->current_match == length) { g_free(priv->command_line); priv->command_line = g_strdup(current_input); } size_t i = 0; const char* command = NULL; while (i < length) { if (priv->reset == true || next == false) { if (priv->current < 1) { priv->reset = false; priv->current = priv->current_match; return NULL; } else { --priv->current; } } else if (next == true) { if (priv->current + 1 >= length) { /* At the bottom of the history, return what the command-line was. */ priv->current_match = length; priv->current = priv->current_match; return priv->command_line; } else { ++priv->current; } } else { return NULL; } command = girara_list_nth(list, priv->current); if (command == NULL) { return NULL; } /* Only match history items starting with what was on the command-line. */ if (g_str_has_prefix(command, priv->command_line)) { priv->reset = false; priv->current_match = priv->current; break; } ++i; } if (i == length) { return NULL; } return command; } static const char* ih_next(GiraraInputHistory* history, const char* current_input) { return find_next(history, current_input, true); } static const char* ih_previous(GiraraInputHistory* history, const char* current_input) { return find_next(history, current_input, false); } static void ih_reset(GiraraInputHistory* history) { ih_private_t* priv = GIRARA_INPUT_HISTORY_GET_PRIVATE(history); priv->reset = true; if (priv->io != NULL) { girara_list_t* list = girara_input_history_list(history); if (list == NULL) { return; } girara_list_clear(list); girara_list_t* newlist = girara_input_history_io_read(priv->io); if (newlist != NULL) { GIRARA_LIST_FOREACH(newlist, const char*, iter, data) girara_list_append(list, g_strdup(data)); GIRARA_LIST_FOREACH_END(newlist, const char*, iter, data); girara_list_free(newlist); } } } /* Wrapper functions for the members */ void girara_input_history_append(GiraraInputHistory* history, const char* input) { g_return_if_fail(GIRARA_IS_INPUT_HISTORY(history) == true); GIRARA_INPUT_HISTORY_GET_CLASS(history)->append(history, input); } girara_list_t* girara_input_history_list(GiraraInputHistory* history) { g_return_val_if_fail(GIRARA_IS_INPUT_HISTORY(history) == true, NULL); return GIRARA_INPUT_HISTORY_GET_CLASS(history)->list(history); } const char* girara_input_history_next(GiraraInputHistory* history, const char* current_input) { g_return_val_if_fail(GIRARA_IS_INPUT_HISTORY(history) == true, NULL); return GIRARA_INPUT_HISTORY_GET_CLASS(history)->next(history, current_input); } const char* girara_input_history_previous(GiraraInputHistory* history, const char* current_input) { g_return_val_if_fail(GIRARA_IS_INPUT_HISTORY(history) == true, NULL); return GIRARA_INPUT_HISTORY_GET_CLASS(history)->previous(history, current_input); } void girara_input_history_reset(GiraraInputHistory* history) { g_return_if_fail(GIRARA_IS_INPUT_HISTORY(history) == true); GIRARA_INPUT_HISTORY_GET_CLASS(history)->reset(history); } girara-0.2.5/girara/input-history.h0000644000175000017500000001230112513025726015703 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_INPUT_HISTORY_H #define GIRARA_INPUT_HISTORY_H #include #include "types.h" struct girara_input_history_io_interface_s { GTypeInterface parent_iface; /* interface methords */ /** * Write a line of input to the input history storage. * * @param io a GiraraInputHistoryIO object * @param input the input */ void (*append)(GiraraInputHistoryIO* io, const char* input); /** * Read all items from the input history storage. * * @param io a GiraraInputHistoryIO object * @returns a list of inputs */ girara_list_t* (*read)(GiraraInputHistoryIO* io); /* reserved for further methods */ void (*reserved1)(void); void (*reserved2)(void); void (*reserved3)(void); void (*reserved4)(void); }; #define GIRARA_TYPE_INPUT_HISTORY_IO \ (girara_input_history_io_get_type()) #define GIRARA_INPUT_HISTORY_IO(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj), GIRARA_TYPE_INPUT_HISTORY_IO, GiraraInputHistoryIO)) #define GIRARA_IS_INPUT_HISTORY_IO(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GIRARA_TYPE_INPUT_HISTORY_IO)) #define GIRARA_INPUT_HISTORY_IO_GET_INTERFACE(obj) \ (G_TYPE_INSTANCE_GET_INTERFACE((obj), GIRARA_TYPE_INPUT_HISTORY_IO, GiraraInputHistoryIOInterface)) GType girara_input_history_io_get_type(void); void girara_input_history_io_append(GiraraInputHistoryIO* io, const char* input); girara_list_t* girara_input_history_io_read(GiraraInputHistoryIO* io); struct girara_input_history_s { GObject parent; }; struct girara_input_history_class_s { GObjectClass parent_class; /* methods */ /** * Append a new line of input. If the io property is set, the input will * be passed on to @ref girara_input_history_io_append. * * @param history an input history instance * @param input the input */ void (*append)(GiraraInputHistory* history, const char* input); /** * Get a list of all the inputs stored. * * @param history an input history instance * @returns a list containing all inputs */ girara_list_t* (*list)(GiraraInputHistory* history); /** * Get the "next" input from the history * * @param history an input history instance * @param current_input input used to find the "next" input * @returns "next" input */ const char* (*next)(GiraraInputHistory* history, const char* current_input); /** * Get the "previous" input from the history * * @param history an input history instance * @param current_input input used to find the "next" input * @returns "previous" input */ const char* (*previous)(GiraraInputHistory* history, const char* current_input); /** * Reset state of the input history, i.e reset any information used to * determine the next input. If the io property is set, the history will be * re-read with @ref girara_input_history_io_read. * * @param history an input history instance */ void (*reset)(GiraraInputHistory* history); /* reserved for further methods */ void (*reserved1)(void); void (*reserved2)(void); void (*reserved3)(void); void (*reserved4)(void); }; #define GIRARA_TYPE_INPUT_HISTORY \ (girara_input_history_get_type ()) #define GIRARA_INPUT_HISTORY(obj) \ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIRARA_TYPE_INPUT_HISTORY, GiraraInputHistory)) #define GIRARA_INPUT_HISTORY_CLASS(obj) \ (G_TYPE_CHECK_CLASS_CAST ((obj), GIRARA_TYPE_INPUT_HISTORY, GiraraInputHistoryClass)) #define GIRARA_IS_INPUT_HISTORY(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIRARA_TYPE_INPUT_HISTORY)) #define GIRARA_IS_INPUT_HISTORY_CLASS(obj) \ (G_TYPE_CHECK_CLASS_TYPE ((obj), GIRARA_TYPE_INPUT_HISTORY)) #define GIRARA_INPUT_HISTORY_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS ((obj), GIRARA_TYPE_INPUT_HISTORY, GiraraInputHistoryClass)) /** * Returns the type of the input history. * * @return the type */ GType girara_input_history_get_type(void); /** * Create new input history object. * * @param io a GiraraInputHistoryIO instance, may be NULL * @returns an input history object */ GiraraInputHistory* girara_input_history_new(GiraraInputHistoryIO* io); /** * Append a new line of input. * * @param history an input history instance * @param input the input */ void girara_input_history_append(GiraraInputHistory* history, const char* input); /** * Get the "next" input from the history * * @param history an input history instance * @param current_input input used to find the "next" input * @returns "next" input */ const char* girara_input_history_next(GiraraInputHistory* history, const char* current_input); /** * Get the "previous" input from the history * * @param history an input history instance * @param current_input input used to find the "next" input * @returns "previous" input */ const char* girara_input_history_previous(GiraraInputHistory* history, const char* current_input); /** * Reset state of the input history * * @param history an input history instance */ void girara_input_history_reset(GiraraInputHistory* history); /** * Get a list of all the inputs stored. * * @param history an input history instance * @returns a list containing all inputs */ girara_list_t* girara_input_history_list(GiraraInputHistory* history); #endif girara-0.2.5/girara/internal.h0000644000175000017500000001520112513025726014663 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_INTERNAL_H #define GIRARA_INTERNAL_H #include #include #include "types.h" #include "macros.h" #define FORMAT_COMMAND "%s" #define FORMAT_DESCRIPTION "%s" #define UNUSED(x) GIRARA_UNUSED(x) #define HIDDEN GIRARA_HIDDEN #define LENGTH(x) (sizeof(x)/sizeof((x)[0])) /** * Free girara_setting_t struct * * @param setting The setting to free. */ HIDDEN void girara_setting_free(girara_setting_t* setting); HIDDEN void girara_config_handle_free(girara_config_handle_t* handle); HIDDEN void girara_shortcut_mapping_free(girara_shortcut_mapping_t* mapping); HIDDEN void girara_shortcut_free(girara_shortcut_t* shortcut); HIDDEN void girara_inputbar_shortcut_free(girara_inputbar_shortcut_t* shortcut); HIDDEN void girara_mode_string_free(girara_mode_string_t* mode); HIDDEN void girara_statusbar_item_free(girara_statusbar_item_t* statusbaritem); HIDDEN void girara_argument_mapping_free( girara_argument_mapping_t* argument_mapping); HIDDEN void girara_special_command_free( girara_special_command_t* special_command); HIDDEN void girara_command_free(girara_command_t* command); HIDDEN void girara_mouse_event_free(girara_mouse_event_t* mouse_event); HIDDEN void girara_config_load_default(girara_session_t* session); HIDDEN void update_state_by_keyval(int *state, int keyval); HIDDEN void widget_add_class(GtkWidget* widget, const char* styleclass); HIDDEN void widget_remove_class(GtkWidget* widget, const char* styleclass); /** * Default complection function for the settings * * @param session The used girara session * @param input The current input */ HIDDEN girara_completion_t* girara_cc_set(girara_session_t* session, const char* input); /** * Default command to map sortcuts * * @param session The used girara session * @param argument_list List of passed arguments * @return TRUE No error occured * @return FALSE An error occured */ HIDDEN bool girara_cmd_map(girara_session_t* session, girara_list_t* argument_list); /** * Default command to unmap sortcuts * * @param session The used girara session * @param argument_list List of passed arguments * @return TRUE No error occured * @return FALSE An error occured */ HIDDEN bool girara_cmd_unmap(girara_session_t* session, girara_list_t* argument_list); /** * Default command to quit the application * * @param session The used girara session * @param argument_list List of passed arguments * @return TRUE No error occured * @return FALSE An error occured */ HIDDEN bool girara_cmd_quit(girara_session_t* session, girara_list_t* argument_list); /** * Default command to set the value of settings * * @param session The used girara session * @param argument_list List of passed arguments * @return TRUE No error occured * @return FALSE An error occured */ HIDDEN bool girara_cmd_set(girara_session_t* session, girara_list_t* argument_list); /** * Execute an external command * * @param session The used girara session * @param argument_list List of passed arguments * @return TRUE No error occured * @return FALSE An error occured */ HIDDEN bool girara_cmd_exec(girara_session_t* session, girara_list_t* argument_list); #ifdef WITH_JSON /** * Dump current settings to a JSON file * * @param session The used girara session * @param argument_list List of passed arguments * @return TRUE No error occured * @return FALSE An error occured */ HIDDEN bool girara_cmd_dump_config(girara_session_t* session, girara_list_t* argument_list); #endif /** * Process argument as a sequence of keys that were typed by the user * * @param session The session * @param argument The argument * @param event Event type * @param t Number of times * @return true No error occured * @return false An error occured */ HIDDEN bool girara_sc_feedkeys(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Structure of a command */ struct girara_command_s { char* command; /**< Name of the command */ char* abbr; /**< Abbreviation of the command */ girara_command_function_t function; /**< Function */ girara_completion_function_t completion; /**< Completion function */ char* description; /**< Description of the command */ }; struct girara_mode_string_s { girara_mode_t index; /**< Index */ char* name; /**< Name of the mode object */ }; /** * Shortcut mapping */ struct girara_shortcut_mapping_s { char* identifier; /**> Identifier string */ girara_shortcut_function_t function; /** Shortcut function */ }; /** * Argument mapping */ struct girara_argument_mapping_s { char* identifier; /**> Identifier string */ int value; /**> Value */ }; /** * Structure of a shortcut */ struct girara_shortcut_s { guint mask; /**< Mask */ guint key; /**< Key */ char* buffered_command; /**< Buffer command */ girara_shortcut_function_t function; /**< The correspondending function */ girara_mode_t mode; /**< Mode identifier */ girara_argument_t argument; /**< Given argument */ }; /** * Structure of a inputbar shortcut */ struct girara_inputbar_shortcut_s { guint mask; /**< Mask */ guint key; /**< Key */ girara_shortcut_function_t function; /**< Function */ girara_argument_t argument; /**< Given argument */ }; /** * Structure of a special command */ struct girara_special_command_s { char identifier; /**< Identifier */ girara_inputbar_special_function_t function; /**< Function */ bool always; /**< Evalute on every change of the input */ girara_argument_t argument; /**< Argument */ }; /** * Structure of a mouse event */ struct girara_mouse_event_s { guint mask; /**< Mask */ guint button; /**< Button */ girara_shortcut_function_t function; /**< Function */ girara_mode_t mode; /**< Allowed modes */ girara_event_type_t event_type; /**< Event type */ girara_argument_t argument; /**< Given argument */ }; /** * Config handle */ struct girara_config_handle_s { char* identifier; girara_command_function_t handle; }; /** * Structure of a statusbar item */ struct girara_statusbar_item_s { GtkWidget* box; /**< Event box */ GtkLabel *text; /**< Text label */ }; /** * Private data of the girara session */ struct girara_session_private_s { /** * Used in session-specific paths */ char* session_name; /** * List of all settings */ girara_list_t* settings; /** * Template enginge for CSS. */ GiraraTemplate* csstemplate; struct { GtkWidget* overlay; /**< So we can overlay bottom_box on top of view */ GtkBox* bottom_box; /**< Box grouping input, status and notification */ GtkCssProvider* cssprovider; } gtk; }; #endif girara-0.2.5/girara/macros.h0000644000175000017500000000340712513025726014340 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_MACROS_H #define GIRARA_MACROS_H #ifndef GIRARA_PRINTF # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4) || defined(__clang__) # define GIRARA_PRINTF(format_idx, arg_idx) \ __attribute__((__format__ (__printf__, format_idx, arg_idx))) # else # define GIRARA_PRINTF(format_idx, arg_idx) # endif #endif #ifndef GIRARA_UNUSED # if defined(__GNUC__) || defined(__clang__) # define GIRARA_UNUSED(x) UNUSED_ ## x __attribute__((unused)) # elif defined(__LCLINT__) # define GIRARA_UNUSED(x) /*@unused@*/ x # else # define GIRARA_UNUSED(x) x # endif #endif #ifndef GIRARA_HIDDEN # if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__) # define GIRARA_HIDDEN __attribute__((visibility("hidden"))) # elif defined(__SUNPRO_C) # define GIRARA_HIDDEN __hidden # else # define GIRARA_HIDDEN # endif #endif #ifndef GIRARA_DEPRECATED # if defined(__GNUC__) # define GIRARA_DEPRECATED(x) x __attribute__((deprecated)) # define GIRARA_DEPRECATED_ __attribute__((deprecated)) # else # define GIRARA_DEPRECATED(x) x # define GIRARA_DEPRECATED_ # endif #endif #ifndef GIRARA_ALLOC_SIZE # if defined(__GNUC__) # define GIRARA_ALLOC_SIZE(...) __attribute__((alloc_size(__VA_ARGS__))) # else # define GIRARA_ALLOC_SIZE(x) # endif #endif #ifndef GIRARA_DO_PRAGMA # if defined(__GNUC__) || defined(__clang__) # define GIRARA_DO_PRAGMA(x) _Pragma(#x) # else # define GIRARA_DO_PRAGMA(x) # endif #endif #ifndef GIRARA_IGNORE_DEPRECATED # define GIRARA_IGNORE_DEPRECATED \ GIRARA_DO_PRAGMA(GCC diagnostic push) \ GIRARA_DO_PRAGMA(GCC diagnostic ignored "-Wdeprecated-declarations") #endif #ifndef GIRARA_UNIGNORE # define GIRARA_UNIGNORE \ GIRARA_DO_PRAGMA(GCC diagnostic pop) #endif #endif girara-0.2.5/girara/session.c0000644000175000017500000006534112635750323014542 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #ifdef WITH_LIBNOTIFY #include #endif #include "session.h" #include "callbacks.h" #include "commands.h" #include "config.h" #include "css-definitions.h" #include "datastructures.h" #include "entry.h" #include "input-history.h" #include "internal.h" #include "settings.h" #include "shortcuts.h" #include "template.h" #include "utils.h" static int cb_sort_settings(girara_setting_t* lhs, girara_setting_t* rhs) { return g_strcmp0(girara_setting_get_name(lhs), girara_setting_get_name(rhs)); } static void ensure_gettext_initialized(void) { static gsize initialized = 0; if (g_once_init_enter(&initialized) == TRUE) { bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); g_once_init_leave(&initialized, 1); } } static void init_template_engine(GiraraTemplate* csstemplate) { static const char* variable_names[] = { "session", "font", "default-fg", "default-bg", "inputbar-fg", "inputbar-bg", "statusbar-fg", "statusbar-bg", "completion-fg", "completion-bg", "completion-group-fg", "completion-group-bg", "completion-highlight-fg", "completion-highlight-bg", "notification-error-fg", "notification-error-bg", "notification-warning-fg", "notification-warning-bg", "notification-fg", "notification-bg", "scrollbar-fg", "scrollbar-bg", "tabbar-fg", "tabbar-bg", "tabbar-focus-fg", "tabbar-focus-bg", "bottombox-padding1", "bottombox-padding2", "bottombox-padding3", "bottombox-padding4" }; for (size_t idx = 0; idx < LENGTH(variable_names); ++idx) { girara_template_add_variable(csstemplate, variable_names[idx]); } } static void fill_template_with_values(girara_session_t* session) { GiraraTemplate* csstemplate = session->private_data->csstemplate; girara_template_set_variable_value(csstemplate, "session", session->private_data->session_name); char* font = NULL; girara_setting_get(session, "font", &font); if (font != NULL) { girara_template_set_variable_value(csstemplate, "font", font); g_free(font); } else { girara_template_set_variable_value(csstemplate, "font", "monospace normal 9"); }; /* parse color values */ const char* color_settings[] = { "default-fg", "default-bg", "inputbar-fg", "inputbar-bg", "statusbar-fg", "statusbar-bg", "completion-fg", "completion-bg", "completion-group-fg", "completion-group-bg", "completion-highlight-fg", "completion-highlight-bg", "notification-error-fg", "notification-error-bg", "notification-warning-fg", "notification-warning-bg", "notification-fg", "notification-bg", "scrollbar-fg", "scrollbar-bg", "tabbar-fg", "tabbar-bg", "tabbar-focus-fg", "tabbar-focus-bg", }; for (size_t i = 0; i < LENGTH(color_settings); i++) { char* tmp_value = NULL; girara_setting_get(session, color_settings[i], &tmp_value); GdkRGBA color = { 0, 0, 0, 0 }; if (tmp_value != NULL) { gdk_rgba_parse(&color, tmp_value); g_free(tmp_value); } char* colorstr = gdk_rgba_to_string(&color); girara_template_set_variable_value(csstemplate, color_settings[i], colorstr); g_free(colorstr); } /* we want inputbar_entry the same height as notification_text and statusbar, so that when inputbar_entry is hidden, the size of the bottom_box remains the same. We need to get rid of the builtin padding in the GtkEntry widget. */ int ypadding = 2; /* total amount of padding (top + bottom) */ int xpadding = 8; /* total amount of padding (left + right) */ girara_setting_get(session, "statusbar-h-padding", &xpadding); girara_setting_get(session, "statusbar-v-padding", &ypadding); typedef struct padding_mapping_s { const char* identifier; char* value; } padding_mapping_t; const padding_mapping_t padding_mapping[] = { {"bottombox-padding1", g_strdup_printf("%d", ypadding - ypadding/2)}, {"bottombox-padding2", g_strdup_printf("%d", xpadding/2)}, {"bottombox-padding3", g_strdup_printf("%d", ypadding/2)}, {"bottombox-padding4", g_strdup_printf("%d", xpadding - xpadding/2)}, }; for (size_t i = 0; i < LENGTH(padding_mapping); ++i) { girara_template_set_variable_value(csstemplate, padding_mapping[i].identifier, padding_mapping[i].value); g_free(padding_mapping[i].value); } } static void css_template_changed(GiraraTemplate* csstemplate, girara_session_t* session) { GtkCssProvider* old = session->private_data->gtk.cssprovider; char* css_data = girara_template_evaluate(csstemplate); if (css_data == NULL) { girara_error("Error while evaluating templates."); return; } GtkCssProvider* provider = gtk_css_provider_new(); GError* error = NULL; if (gtk_css_provider_load_from_data(provider, css_data, -1, &error) == FALSE) { girara_error("Unable to load CSS: %s", error->message); g_free(css_data); g_error_free(error); g_object_unref(provider); return; } g_free(css_data); /* add CSS style provider */ GdkDisplay* display = gdk_display_get_default(); GdkScreen* screen = gdk_display_get_default_screen(display); gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); if (old != NULL) { gtk_style_context_remove_provider_for_screen(screen, GTK_STYLE_PROVIDER(old)); g_object_unref(old); gtk_widget_queue_draw(GTK_WIDGET(session->gtk.window)); } session->private_data->gtk.cssprovider = provider; } girara_session_t* girara_session_create() { ensure_gettext_initialized(); girara_session_t* session = g_slice_alloc0(sizeof(girara_session_t)); session->private_data = g_slice_alloc0(sizeof(girara_session_private_t)); /* init values */ session->bindings.mouse_events = girara_list_new2( (girara_free_function_t) girara_mouse_event_free); session->bindings.commands = girara_list_new2( (girara_free_function_t) girara_command_free); session->bindings.special_commands = girara_list_new2( (girara_free_function_t) girara_special_command_free); session->bindings.shortcuts = girara_list_new2( (girara_free_function_t) girara_shortcut_free); session->bindings.inputbar_shortcuts = girara_list_new2( (girara_free_function_t) girara_inputbar_shortcut_free); session->elements.statusbar_items = girara_list_new2( (girara_free_function_t) girara_statusbar_item_free); /* settings */ session->private_data->settings = girara_sorted_list_new2( (girara_compare_function_t) cb_sort_settings, (girara_free_function_t) girara_setting_free); /* CSS style provider */ session->private_data->csstemplate = girara_template_new(CSS_TEMPLATE); session->private_data->gtk.cssprovider = NULL; init_template_engine(session->private_data->csstemplate); /* init modes */ session->modes.identifiers = girara_list_new2( (girara_free_function_t) girara_mode_string_free); girara_mode_t normal_mode = girara_mode_add(session, "normal"); girara_mode_t inputbar_mode = girara_mode_add(session, "inputbar"); session->modes.normal = normal_mode; session->modes.current_mode = normal_mode; session->modes.inputbar = inputbar_mode; /* config handles */ session->config.handles = girara_list_new2( (girara_free_function_t) girara_config_handle_free); session->config.shortcut_mappings = girara_list_new2( (girara_free_function_t) girara_shortcut_mapping_free); session->config.argument_mappings = girara_list_new2( (girara_free_function_t) girara_argument_mapping_free); /* command history */ session->command_history = girara_input_history_new(NULL); /* load default values */ girara_config_load_default(session); /* create widgets */ session->gtk.box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); session->private_data->gtk.overlay = gtk_overlay_new(); session->private_data->gtk.bottom_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); session->gtk.statusbar_entries = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); session->gtk.tabbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); session->gtk.inputbar_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_box_set_homogeneous(GTK_BOX(session->gtk.tabbar), TRUE); gtk_box_set_homogeneous(session->gtk.inputbar_box, TRUE); session->gtk.view = gtk_scrolled_window_new(NULL, NULL); session->gtk.viewport = gtk_viewport_new(NULL, NULL); gtk_widget_add_events(session->gtk.viewport, GDK_SCROLL_MASK); session->gtk.statusbar = gtk_event_box_new(); session->gtk.notification_area = gtk_event_box_new(); session->gtk.notification_text = gtk_label_new(NULL); session->gtk.inputbar_dialog = GTK_LABEL(gtk_label_new(NULL)); session->gtk.inputbar_entry = GTK_ENTRY(girara_entry_new()); session->gtk.inputbar = gtk_event_box_new(); session->gtk.tabs = GTK_NOTEBOOK(gtk_notebook_new()); return session; } bool girara_session_init(girara_session_t* session, const char* sessionname) { if (session == NULL) { return false; } bool smooth_scroll = false; girara_setting_get(session, "smooth-scroll", &smooth_scroll); if (smooth_scroll) { gtk_widget_add_events(session->gtk.viewport, GDK_SMOOTH_SCROLL_MASK); } session->private_data->session_name = g_strdup( (sessionname == NULL) ? "girara" : sessionname); /* load CSS style */ fill_template_with_values(session); g_signal_connect(G_OBJECT(session->private_data->csstemplate), "changed", G_CALLBACK(css_template_changed), session); /* window */ #ifdef GDK_WINDOWING_X11 if (session->gtk.embed != 0) { session->gtk.window = gtk_plug_new(session->gtk.embed); } else { #endif session->gtk.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); #ifdef GDK_WINDOWING_X11 } #endif gtk_widget_set_name(GTK_WIDGET(session->gtk.window), session->private_data->session_name); /* apply CSS style */ css_template_changed(session->private_data->csstemplate, session); GdkGeometry hints = { .base_height = 1, .base_width = 1, .height_inc = 0, .max_aspect = 0, .max_height = 0, .max_width = 0, .min_aspect = 0, .min_height = 0, .min_width = 0, .width_inc = 0 }; gtk_window_set_geometry_hints(GTK_WINDOW(session->gtk.window), NULL, &hints, GDK_HINT_MIN_SIZE); /* view */ session->signals.view_key_pressed = g_signal_connect(G_OBJECT(session->gtk.view), "key-press-event", G_CALLBACK(girara_callback_view_key_press_event), session); session->signals.view_button_press_event = g_signal_connect(G_OBJECT(session->gtk.view), "button-press-event", G_CALLBACK(girara_callback_view_button_press_event), session); session->signals.view_button_release_event = g_signal_connect(G_OBJECT(session->gtk.view), "button-release-event", G_CALLBACK(girara_callback_view_button_release_event), session); session->signals.view_motion_notify_event = g_signal_connect(G_OBJECT(session->gtk.view), "motion-notify-event", G_CALLBACK(girara_callback_view_button_motion_notify_event), session); session->signals.view_scroll_event = g_signal_connect(G_OBJECT(session->gtk.view), "scroll-event", G_CALLBACK(girara_callback_view_scroll_event), session); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(session->gtk.view), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* invisible scrollbars */ GtkWidget *vscrollbar = gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(session->gtk.view)); GtkWidget *hscrollbar = gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(session->gtk.view)); char* guioptions = NULL; girara_setting_get(session, "guioptions", &guioptions); if (vscrollbar != NULL && strchr(guioptions, 'v') == NULL) { gtk_widget_set_state_flags(vscrollbar, GTK_STATE_FLAG_INSENSITIVE, false); } if (hscrollbar != NULL) { if (strchr(guioptions, 'h') == NULL) { gtk_widget_set_state_flags(hscrollbar, GTK_STATE_FLAG_INSENSITIVE, false); } } g_free(guioptions); /* viewport */ gtk_container_add(GTK_CONTAINER(session->gtk.view), session->gtk.viewport); gtk_viewport_set_shadow_type(GTK_VIEWPORT(session->gtk.viewport), GTK_SHADOW_NONE); /* statusbar */ gtk_container_add(GTK_CONTAINER(session->gtk.statusbar), GTK_WIDGET(session->gtk.statusbar_entries)); /* notification area */ gtk_container_add(GTK_CONTAINER(session->gtk.notification_area), session->gtk.notification_text); gtk_widget_set_halign(session->gtk.notification_text, GTK_ALIGN_START); gtk_widget_set_valign(session->gtk.notification_text, GTK_ALIGN_CENTER); gtk_label_set_use_markup(GTK_LABEL(session->gtk.notification_text), TRUE); /* inputbar */ gtk_entry_set_has_frame(session->gtk.inputbar_entry, FALSE); gtk_editable_set_editable(GTK_EDITABLE(session->gtk.inputbar_entry), TRUE); widget_add_class(GTK_WIDGET(session->gtk.inputbar_entry), "bottom_box"); widget_add_class(session->gtk.notification_text, "bottom_box"); session->signals.inputbar_key_pressed = g_signal_connect( G_OBJECT(session->gtk.inputbar_entry), "key-press-event", G_CALLBACK(girara_callback_inputbar_key_press_event), session ); session->signals.inputbar_changed = g_signal_connect( G_OBJECT(session->gtk.inputbar_entry), "changed", G_CALLBACK(girara_callback_inputbar_changed_event), session ); session->signals.inputbar_activate = g_signal_connect( G_OBJECT(session->gtk.inputbar_entry), "activate", G_CALLBACK(girara_callback_inputbar_activate), session ); gtk_box_set_homogeneous(session->gtk.inputbar_box, FALSE); gtk_box_set_spacing(session->gtk.inputbar_box, 5); /* inputbar box */ gtk_box_pack_start(GTK_BOX(session->gtk.inputbar_box), GTK_WIDGET(session->gtk.inputbar_dialog), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(session->gtk.inputbar_box), GTK_WIDGET(session->gtk.inputbar_entry), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(session->gtk.inputbar), GTK_WIDGET(session->gtk.inputbar_box)); /* bottom box */ gtk_box_set_spacing(session->private_data->gtk.bottom_box, 0); gtk_box_pack_end(GTK_BOX(session->private_data->gtk.bottom_box), GTK_WIDGET(session->gtk.inputbar), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(session->private_data->gtk.bottom_box), GTK_WIDGET(session->gtk.notification_area), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(session->private_data->gtk.bottom_box), GTK_WIDGET(session->gtk.statusbar), TRUE, TRUE, 0); /* tabs */ gtk_notebook_set_show_border(session->gtk.tabs, FALSE); gtk_notebook_set_show_tabs(session->gtk.tabs, FALSE); /* packing */ gtk_box_set_spacing(session->gtk.box, 0); gtk_box_pack_start(session->gtk.box, GTK_WIDGET(session->gtk.tabbar), FALSE, FALSE, 0); gtk_box_pack_start(session->gtk.box, GTK_WIDGET(session->gtk.view), TRUE, TRUE, 0); /* box */ gtk_container_add(GTK_CONTAINER(session->private_data->gtk.overlay), GTK_WIDGET(session->gtk.box)); /* overlay */ g_object_set(session->private_data->gtk.bottom_box, "halign", GTK_ALIGN_FILL, NULL); g_object_set(session->private_data->gtk.bottom_box, "valign", GTK_ALIGN_END, NULL); gtk_overlay_add_overlay(GTK_OVERLAY(session->private_data->gtk.overlay), GTK_WIDGET(session->private_data->gtk.bottom_box)); gtk_container_add(GTK_CONTAINER(session->gtk.window), GTK_WIDGET(session->private_data->gtk.overlay)); /* statusbar */ widget_add_class(GTK_WIDGET(session->gtk.statusbar), "statusbar"); /* inputbar */ widget_add_class(GTK_WIDGET(session->gtk.inputbar_box), "inputbar"); widget_add_class(GTK_WIDGET(session->gtk.inputbar_entry), "inputbar"); widget_add_class(GTK_WIDGET(session->gtk.inputbar), "inputbar"); widget_add_class(GTK_WIDGET(session->gtk.inputbar_dialog), "inputbar"); /* notification area */ widget_add_class(session->gtk.notification_area, "notification"); widget_add_class(session->gtk.notification_text, "notification"); /* set window size */ int window_width = 0; int window_height = 0; girara_setting_get(session, "window-width", &window_width); girara_setting_get(session, "window-height", &window_height); if (window_width > 0 && window_height > 0) { gtk_window_set_default_size(GTK_WINDOW(session->gtk.window), window_width, window_height); } gtk_widget_show_all(GTK_WIDGET(session->gtk.window)); gtk_widget_hide(GTK_WIDGET(session->gtk.notification_area)); gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar_dialog)); if (session->global.autohide_inputbar == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); } if (session->global.hide_statusbar == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.statusbar)); } char* window_icon = NULL; girara_setting_get(session, "window-icon", &window_icon); if (window_icon != NULL) { if (strlen(window_icon) != 0) { girara_setting_set(session, "window-icon", window_icon); } g_free(window_icon); } gtk_widget_grab_focus(GTK_WIDGET(session->gtk.view)); return true; } static void girara_session_private_free(girara_session_private_t* session) { g_return_if_fail(session != NULL); if (session->session_name != NULL) { g_free(session->session_name); } /* clean up CSS style provider */ if (session->gtk.cssprovider != NULL) { g_object_unref(session->gtk.cssprovider); } session->gtk.cssprovider = NULL; if (session->csstemplate != NULL) { g_object_unref(session->csstemplate); } session->csstemplate = NULL; /* clean up settings */ girara_list_free(session->settings); session->settings = NULL; g_slice_free(girara_session_private_t, session); } bool girara_session_destroy(girara_session_t* session) { g_return_val_if_fail(session != NULL, FALSE); /* clean up shortcuts */ girara_list_free(session->bindings.shortcuts); session->bindings.shortcuts = NULL; /* clean up inputbar shortcuts */ girara_list_free(session->bindings.inputbar_shortcuts); session->bindings.inputbar_shortcuts = NULL; /* clean up commands */ girara_list_free(session->bindings.commands); session->bindings.commands = NULL; /* clean up special commands */ girara_list_free(session->bindings.special_commands); session->bindings.special_commands = NULL; /* clean up mouse events */ girara_list_free(session->bindings.mouse_events); session->bindings.mouse_events = NULL; /* clean up input histry */ g_object_unref(session->command_history); session->command_history = NULL; /* clean up statusbar items */ girara_list_free(session->elements.statusbar_items); session->elements.statusbar_items = NULL; /* clean up config handles */ girara_list_free(session->config.handles); session->config.handles = NULL; /* clean up shortcut mappings */ girara_list_free(session->config.shortcut_mappings); session->config.shortcut_mappings = NULL; /* clean up argument mappings */ girara_list_free(session->config.argument_mappings); session->config.argument_mappings = NULL; /* clean up modes */ girara_list_free(session->modes.identifiers); session->modes.identifiers = NULL; /* clean up buffer */ if (session->buffer.command) { g_string_free(session->buffer.command, TRUE); } if (session->global.buffer) { g_string_free(session->global.buffer, TRUE); } session->buffer.command = NULL; session->global.buffer = NULL; /* clean up private data */ girara_session_private_free(session->private_data); session->private_data = NULL; /* clean up session */ g_slice_free(girara_session_t, session); return TRUE; } char* girara_buffer_get(girara_session_t* session) { g_return_val_if_fail(session != NULL, NULL); return (session->global.buffer) ? g_strdup(session->global.buffer->str) : NULL; } void girara_libnotify(girara_session_t* session, const char *summary, const char *body) { if (session == NULL || summary == NULL || body == NULL) { return; } #ifdef WITH_LIBNOTIFY bool was_initialized = notify_is_initted(); if (!was_initialized) { notify_init(session->private_data->session_name); } NotifyNotification* libnotify_notification = NULL; char* icon_name = NULL; /* We use the NotifyNotification constructor at many branches because * libnotify does not have a notify_notification_set_image_from_name() * function, and accessing private fields is frowned upon and subject to API * changes. */ icon_name = g_strdup(gtk_window_get_icon_name(GTK_WINDOW(session->gtk.window))); if (icon_name != NULL) { /* Icon can be loaded from theme with adequate quality for notification */ libnotify_notification = notify_notification_new(summary, body, icon_name); g_free(icon_name); } else { /* Or extracted from the current window */ GdkPixbuf* icon_pix = gtk_window_get_icon(GTK_WINDOW(session->gtk.window)); if (icon_pix != NULL) { libnotify_notification = notify_notification_new(summary, body, NULL); notify_notification_set_image_from_pixbuf(libnotify_notification, icon_pix); g_object_unref(G_OBJECT(icon_pix)); } else { /* Or from a default image as a last resort */ libnotify_notification = notify_notification_new(summary, body, "info"); } } g_return_if_fail(libnotify_notification != NULL); notify_notification_show(libnotify_notification, NULL); g_object_unref(G_OBJECT(libnotify_notification)); if (!was_initialized) { notify_uninit(); } #else girara_notify(session, GIRARA_WARNING, "Girara was compiled without libnotify support."); #endif } void girara_notify(girara_session_t* session, int level, const char* format, ...) { if (session == NULL || session->gtk.notification_text == NULL || session->gtk.notification_area == NULL || session->gtk.inputbar == NULL || session->gtk.view == NULL) { return; } bool error_class = false; bool warning_class = false; switch (level) { case GIRARA_ERROR: error_class = true; break; case GIRARA_WARNING: warning_class = true; break; case GIRARA_INFO: break; default: return; } if (error_class == true) { widget_add_class(session->gtk.notification_area, "notification-error"); widget_add_class(session->gtk.notification_text, "notification-error"); } else { widget_remove_class(session->gtk.notification_area, "notification-error"); widget_remove_class(session->gtk.notification_text, "notification-error"); } if (warning_class == true) { widget_add_class(session->gtk.notification_area, "notification-warning"); widget_add_class(session->gtk.notification_text, "notification-warning"); } else { widget_remove_class(session->gtk.notification_area, "notification-warning"); widget_remove_class(session->gtk.notification_text, "notification-warning"); } /* prepare message */ va_list ap; va_start(ap, format); char* message = g_strdup_vprintf(format, ap); va_end(ap); gtk_label_set_markup(GTK_LABEL(session->gtk.notification_text), message); g_free(message); /* update visibility */ gtk_widget_show(GTK_WIDGET(session->gtk.notification_area)); gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); gtk_widget_grab_focus(GTK_WIDGET(session->gtk.view)); } void girara_dialog(girara_session_t* session, const char* dialog, bool invisible, girara_callback_inputbar_key_press_event_t key_press_event, girara_callback_inputbar_activate_t activate_event, void* data) { if (session == NULL || session->gtk.inputbar == NULL || session->gtk.inputbar_dialog == NULL || session->gtk.inputbar_entry == NULL) { return; } gtk_widget_show(GTK_WIDGET(session->gtk.inputbar_dialog)); /* set dialog message */ if (dialog != NULL) { gtk_label_set_markup(session->gtk.inputbar_dialog, dialog); } /* set input visibility */ if (invisible == true) { gtk_entry_set_visibility(session->gtk.inputbar_entry, FALSE); } else { gtk_entry_set_visibility(session->gtk.inputbar_entry, TRUE); } /* set handler */ session->signals.inputbar_custom_activate = activate_event; session->signals.inputbar_custom_key_press_event = key_press_event; session->signals.inputbar_custom_data = data; /* focus inputbar */ girara_sc_focus_inputbar(session, NULL, NULL, 0); } bool girara_set_view(girara_session_t* session, GtkWidget* widget) { g_return_val_if_fail(session != NULL, false); GtkWidget* child = gtk_bin_get_child(GTK_BIN(session->gtk.viewport)); if (child != NULL) { g_object_ref(child); gtk_container_remove(GTK_CONTAINER(session->gtk.viewport), child); } gtk_container_add(GTK_CONTAINER(session->gtk.viewport), widget); gtk_widget_show_all(widget); gtk_widget_grab_focus(session->gtk.view); return true; } void girara_mode_set(girara_session_t* session, girara_mode_t mode) { g_return_if_fail(session != NULL); session->modes.current_mode = mode; } girara_mode_t girara_mode_add(girara_session_t* session, const char* name) { g_return_val_if_fail(session != NULL, FALSE); g_return_val_if_fail(name != NULL && name[0] != '\0', FALSE); girara_mode_t last_index = 0; GIRARA_LIST_FOREACH(session->modes.identifiers, girara_mode_string_t*, iter, mode) if (mode->index > last_index) { last_index = mode->index; } GIRARA_LIST_FOREACH_END(session->modes.identifiers, girara_mode_string_t*, iter, mode); /* create new mode identifier */ girara_mode_string_t* mode = g_slice_new(girara_mode_string_t); mode->index = last_index + 1; mode->name = g_strdup(name); girara_list_append(session->modes.identifiers, mode); return mode->index; } void girara_mode_string_free(girara_mode_string_t* mode) { if (mode == NULL) { return; } g_free(mode->name); g_slice_free(girara_mode_string_t, mode); } girara_mode_t girara_mode_get(girara_session_t* session) { g_return_val_if_fail(session != NULL, 0); return session->modes.current_mode; } bool girara_set_window_title(girara_session_t* session, const char* name) { if (session == NULL || session->gtk.window == NULL || name == NULL) { return false; } gtk_window_set_title(GTK_WINDOW(session->gtk.window), name); return true; } bool girara_set_window_icon(girara_session_t* session, const char* name) { if (session == NULL || session->gtk.window == NULL || name == NULL) { return false; } gtk_window_set_icon_name(GTK_WINDOW(session->gtk.window), name); return true; } girara_list_t* girara_get_command_history(girara_session_t* session) { g_return_val_if_fail(session != NULL, NULL); return girara_input_history_list(session->command_history); } GiraraTemplate* girara_session_get_template(girara_session_t* session) { g_return_val_if_fail(session != NULL, NULL); return session->private_data->csstemplate; } girara-0.2.5/girara/session.h0000644000175000017500000001676412513025726014551 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_SESSION_H #define GIRARA_SESSION_H #include "types.h" #include "macros.h" #include "callbacks.h" #include #ifdef GDK_WINDOWING_X11 #include #endif #include struct girara_session_s { struct { GtkWidget *window; /**< The main window of the application */ GtkBox *box; /**< A box that contains all widgets */ GtkWidget *view; /**< The view area of the applications widgets */ GtkWidget *viewport; /**< The viewport of view */ GtkWidget *statusbar; /**< The statusbar */ GtkBox *statusbar_entries; /**< Statusbar entry box */ GtkWidget *notification_area; /**< The notification area */ GtkWidget *notification_text; /**< The notification entry */ GtkWidget *tabbar; /**< The tabbar */ GtkBox *inputbar_box; /**< Inputbar box */ GtkWidget *inputbar; /**< Inputbar event box */ GtkLabel *inputbar_dialog; /**< Inputbar dialog */ GtkEntry *inputbar_entry; /**< Inputbar entry */ GtkNotebook *tabs; /**< The tabs notebook */ GtkBox *results; /**< Completion results */ #ifdef GDK_WINDOWING_X11 Window embed; /**< Embedded window */ #endif } gtk; struct { girara_list_t* mouse_events; /**< List of mouse events */ girara_list_t* commands; /**< List of commands */ girara_list_t* shortcuts; /**< List of shortcuts */ girara_list_t* special_commands; /**< List of special commands */ girara_list_t* inputbar_shortcuts; /**< List of inputbar shortcuts */ } bindings; struct { girara_list_t* statusbar_items; /**< List of statusbar items */ } elements; struct { int inputbar_activate; /**< Inputbar activation */ int inputbar_key_pressed; /**< Pressed key in inputbar */ int inputbar_changed; /**< Inputbar text changed */ int view_key_pressed; /**< Pressed key in view */ int view_button_press_event; /**< Pressed button */ int view_button_release_event; /**< Released button */ int view_motion_notify_event; /**< Cursor movement event */ int view_scroll_event; /**< Scroll event */ girara_callback_inputbar_activate_t inputbar_custom_activate; /**< Custom handler */ girara_callback_inputbar_key_press_event_t inputbar_custom_key_press_event; /**< Custom handler */ void* inputbar_custom_data; /**< Data for custom handler */ } signals; struct { void (*buffer_changed)(girara_session_t* session); /**< Buffer changed */ bool (*unknown_command)(girara_session_t* session, const char* input); /**< Unknown command */ } events; struct { GString *buffer; /**< Buffer */ void* data; /**< User data */ bool autohide_inputbar; /**< Auto-hide inputbar */ bool hide_statusbar; /**< Hide statusbar */ } global; struct { girara_mode_t current_mode; /**< Current mode */ girara_list_t *identifiers; /**< List of modes with its string identifiers */ girara_mode_t normal; /**< The normal mode */ girara_mode_t inputbar; /**< The inputbar mode */ } modes; struct { int n; /**< Numeric buffer */ GString *command; /**< Command in buffer */ } buffer; struct { girara_list_t* handles; girara_list_t* shortcut_mappings; girara_list_t* argument_mappings; } config; GiraraInputHistory* command_history; /**< Command history */ girara_session_private_t* private_data; /**< Private data of a girara session */ }; /** * Creates a girara session * * @return A valid session object * @return NULL when an error occured */ girara_session_t* girara_session_create(); /** * Initializes an girara session * * @param session The used girara session * @param appname Name of the session (can be NULL) * @return TRUE No error occured * @return FALSE An error occured */ bool girara_session_init(girara_session_t* session, const char* appname); /** * Destroys an girara session * * @param session The used girara session * @return TRUE No error occured * @return FALSE An error occured */ bool girara_session_destroy(girara_session_t* session); /** * Sets the view widget of girara * * @param session The used girara session * @param widget The widget that should be displayed * @return TRUE No error occured * @return FALSE An error occured */ bool girara_set_view(girara_session_t* session, GtkWidget* widget); /** * Returns a copy of the buffer * * @param session The used girara session * @return Copy of the current buffer */ char* girara_buffer_get(girara_session_t* session); /** * Displays a notification popup for the user using libnotify. Basic styling * is allowed using Pango's markup format: * * * @param session The girara session * @param summary The title * @param body The content */ void girara_libnotify(girara_session_t* session, const char *summary, const char *body); /** * Displays a notification for the user. It is possible to pass GIRARA_INFO, * GIRARA_WARNING or GIRARA_ERROR as a notification level. * * @param session The girara session * @param level The level * @param format String format * @param ... */ void girara_notify(girara_session_t* session, int level, const char* format, ...) GIRARA_PRINTF(3, 4); /** * Creates a girara dialog * * @param session The girara session * @param dialog The dialog message * @param invisible Sets the input visibility * @param key_press_event Callback function to a custom key press event handler * @param activate_event Callback function to a custom activate event handler * @param data Custom data that is passed to the callback functions */ void girara_dialog(girara_session_t* session, const char* dialog, bool invisible, girara_callback_inputbar_key_press_event_t key_press_event, girara_callback_inputbar_activate_t activate_event, void* data); /** * Adds a new mode by its string identifier * * @param session The used girara session * @param name The string identifier used in configs/inputbar etc to refer by * @return A newly defined girara_mode_t associated with name */ girara_mode_t girara_mode_add(girara_session_t* session, const char* name); /** * Sets the current mode * * @param session The used girara session * @param mode The new mode */ void girara_mode_set(girara_session_t* session, girara_mode_t mode); /** * Returns the current mode * * @param session The used girara session * @return The current mode */ girara_mode_t girara_mode_get(girara_session_t* session); /** * Set name of the window title * * @param session The used girara session * @param name The new name of the session * @return true if no error occured * @return false if an error occured */ bool girara_set_window_title(girara_session_t* session, const char* name); /** * Set icon of the window * * @param session The used girara session * @param name the name of the themed icon * @return true if no error occured * @return false if an error occured */ bool girara_set_window_icon(girara_session_t* session, const char* name); /** * Returns the command history * * @param session The used girara session * @return The command history (list of strings) or NULL */ girara_list_t* girara_get_command_history(girara_session_t* session); /** * Returns the internal template object to apply custom theming options * * @param session The girara session * @returns GiraraTemplate object */ GiraraTemplate* girara_session_get_template(girara_session_t* session); #endif girara-0.2.5/girara/settings.c0000644000175000017500000002026612513025726014711 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include #include #ifdef WITH_JSON #include #endif #include "settings.h" #include "datastructures.h" #include "completion.h" #include "session.h" #include "internal.h" #include "utils.h" /** * Structure of a settings entry */ struct girara_setting_s { char* name; /**< Name of the setting */ union { bool b; /**< Boolean */ int i; /**< Integer */ float f; /**< Floating number */ char *s; /**< String */ } value; /**< Value of the setting */ girara_setting_type_t type; /**< Type identifier */ bool init_only; /**< Option can be set only before girara gets initialized */ char* description; /**< Description of this setting */ girara_setting_callback_t callback; /**< Callback that gets executed when the value of the setting changes */ void* data; /**< Arbitrary data that can be used by callbacks */ }; void girara_setting_set_value(girara_session_t* session, girara_setting_t* setting, void* value) { g_return_if_fail(setting && (value || setting->type == STRING)); switch(setting->type) { case BOOLEAN: setting->value.b = *((bool *) value); break; case FLOAT: setting->value.f = *((float *) value); break; case INT: setting->value.i = *((int *) value); break; case STRING: if (setting->value.s != NULL) { g_free(setting->value.s); } setting->value.s = value ? g_strdup(value) : NULL; break; default: g_assert(false); } if (session && setting->callback != NULL) { setting->callback(session, setting->name, setting->type, value, setting->data); } } bool girara_setting_add(girara_session_t* session, const char* name, void* value, girara_setting_type_t type, bool init_only, const char* description, girara_setting_callback_t callback, void* data) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(name != NULL, false); g_return_val_if_fail(type != UNKNOWN, false); if (type != STRING && value == NULL) { return false; } /* search for existing setting */ if (girara_setting_find(session, name) != NULL) { return false; } /* add new setting */ girara_setting_t* setting = g_slice_new0(girara_setting_t); setting->name = g_strdup(name); setting->type = type; setting->init_only = init_only; setting->description = description ? g_strdup(description) : NULL; setting->callback = callback; setting->data = data; girara_setting_set_value(NULL, setting, value); girara_list_append(session->private_data->settings, setting); return true; } bool girara_setting_set(girara_session_t* session, const char* name, void* value) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(name != NULL, false); girara_setting_t* setting = girara_setting_find(session, name); if (setting == NULL) { return false; } girara_setting_set_value(session, setting, value); return true; } bool girara_setting_get_value(girara_setting_t* setting, void* dest) { g_return_val_if_fail(setting != NULL && dest != NULL, false); bool *bvalue = (bool*) dest; float *fvalue = (float*) dest; int *ivalue = (int*) dest; char **svalue = (char**) dest; switch(setting->type) { case BOOLEAN: *bvalue = setting->value.b; break; case FLOAT: *fvalue = setting->value.f; break; case INT: *ivalue = setting->value.i; break; case STRING: *svalue = setting->value.s ? g_strdup(setting->value.s) : NULL; break; default: g_assert(false); } return true; } bool girara_setting_get(girara_session_t* session, const char* name, void* dest) { g_return_val_if_fail(session != NULL && name != NULL && dest != NULL, false); girara_setting_t* setting = girara_setting_find(session, name); if (setting == NULL) { return false; } return girara_setting_get_value(setting, dest); } void girara_setting_free(girara_setting_t* setting) { if (!setting) { return; } g_free(setting->name); g_free(setting->description); if (setting->type == STRING) { g_free(setting->value.s); } g_slice_free(girara_setting_t, setting); } girara_setting_t* girara_setting_find(girara_session_t* session, const char* name) { g_return_val_if_fail(session != NULL, NULL); g_return_val_if_fail(name != NULL, NULL); girara_setting_t* result = NULL; GIRARA_LIST_FOREACH(session->private_data->settings, girara_setting_t*, iter, setting) if (g_strcmp0(setting->name, name) == 0) { result = setting; break; } GIRARA_LIST_FOREACH_END(session->private_data->settings, girara_setting_t*, iter, setting); return result; } const char* girara_setting_get_name(girara_setting_t* setting) { g_return_val_if_fail(setting, NULL); return setting->name; } girara_setting_type_t girara_setting_get_type(girara_setting_t* setting) { g_return_val_if_fail(setting, UNKNOWN); return setting->type; } girara_completion_t* girara_cc_set(girara_session_t* session, const char* input) { if (input == NULL) { return NULL; } girara_completion_t* completion = girara_completion_init(); if (completion == NULL) { return NULL; } girara_completion_group_t* group = girara_completion_group_create(session, NULL); if (group == NULL) { girara_completion_free(completion); return NULL; } girara_completion_add_group(completion, group); unsigned int input_length = strlen(input); GIRARA_LIST_FOREACH(session->private_data->settings, girara_setting_t*, iter, setting) if ((setting->init_only == false) && (input_length <= strlen(setting->name)) && !strncmp(input, setting->name, input_length)) { girara_completion_group_add_element(group, setting->name, setting->description); } GIRARA_LIST_FOREACH_END(session->private_data->settings, girara_setting_t*, iter, setting); return completion; } #ifdef WITH_JSON bool girara_cmd_dump_config(girara_session_t* session, girara_list_t* argument_list) { if (session == NULL || argument_list == NULL) { return false; } const size_t number_of_arguments = girara_list_size(argument_list); if (number_of_arguments != 1) { girara_warning("Invalid number of arguments passed: %zu instead of 1", number_of_arguments); girara_notify(session, GIRARA_ERROR, _("Invalid number of arguments passed: %zu instead of 1"), number_of_arguments); return false; return false; } json_object* json_config = json_object_new_object(); GIRARA_LIST_FOREACH(session->private_data->settings, girara_setting_t*, iter, setting) json_object* json_setting = json_object_new_object(); json_object* json_value = NULL; json_object* json_type = NULL; switch(setting->type) { case BOOLEAN: json_value = json_object_new_boolean(setting->value.b); json_type = json_object_new_string("boolean"); break; case FLOAT: json_value = json_object_new_double(setting->value.f); json_type = json_object_new_string("float"); break; case INT: json_value = json_object_new_int(setting->value.i); json_type = json_object_new_string("int"); break; case STRING: json_value = json_object_new_string(setting->value.s ? setting->value.s : ""); json_type = json_object_new_string("string"); break; default: girara_debug("Invalid setting: %s", setting->name); } if (json_value != NULL) { json_object_object_add(json_setting, "value", json_value); json_object_object_add(json_setting, "type", json_type); } if (setting->description != NULL) { json_object_object_add(json_setting, "description", json_object_new_string(setting->description)); } json_object_object_add(json_setting, "init-only", json_object_new_boolean(setting->init_only)); json_object_object_add(json_config, setting->name, json_setting); GIRARA_LIST_FOREACH_END(session->private_data->settings, girara_setting_t*, iter, setting); json_object_to_file_ext(girara_list_nth(argument_list, 0), json_config, JSON_C_TO_STRING_PRETTY); json_object_put(json_config); return true; } #endif girara-0.2.5/girara/settings.h0000644000175000017500000000540412513025726014713 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_SETTINGS_H #define GIRARA_SETTINGS_H #include "types.h" /** * Adds an additional entry in the settings list * * @param session The used girara session * @param name The name of the setting * @param value The value of the setting * @param type The type of the setting * @param init_only Will only available on initialization * @param description Description of the setting * @param callback Function that is called when the setting changes * @param data Arbitary data that can be used by callbacks * @return TRUE No error occured * @return FALSE An error occured */ bool girara_setting_add(girara_session_t* session, const char* name, void* value, girara_setting_type_t type, bool init_only, const char* description, girara_setting_callback_t callback, void* data); /** * Sets the value of a setting * * @param session The used girara session * @param name The name of the setting * @param value The new value of the setting * @return TRUE No error occured * @return FALSE An error occured */ bool girara_setting_set(girara_session_t* session, const char* name, void* value); /** * Retreive the value of a setting. If the setting is a string, the value stored * in dest has to be deallocated with g_free. * @param session The used girara session * @param name The name of the setting * @param dest A pointer to the destination of the result. * @return true if the setting exists, false otherwise. */ bool girara_setting_get(girara_session_t* session, const char* name, void* dest); /** * Find a setting. * * @param session The girara session * @param name name of the setting * @return the setting or NULL if it doesn't exist */ girara_setting_t* girara_setting_find(girara_session_t* session, const char* name); /** * Get the setting's name. * * @param setting The setting * @return the setting's name */ const char* girara_setting_get_name(girara_setting_t* setting); /** * Get the setting's value. If the setting is a string, the value stored * in dest has to be deallocated with g_free. * * @param setting The setting * @param dest A pointer to the destination of the result. * @return true if the setting exists, false otherwise. */ bool girara_setting_get_value(girara_setting_t* setting, void* dest); /** * Get the setting's value. * * @param setting The setting * @return the value */ girara_setting_type_t girara_setting_get_type(girara_setting_t* setting); /** * Set the setting's value. If session is NULL, the setting's callback won't be * called. * * @param session The girara session * @param setting The setting * @param value The new value */ void girara_setting_set_value(girara_session_t* session, girara_setting_t* setting, void* value); #endif girara-0.2.5/girara/shortcuts.c0000644000175000017500000005710512635750323015114 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "shortcuts.h" #include "datastructures.h" #include "internal.h" #include "session.h" #include "settings.h" #include "tabs.h" #include "input-history.h" #include #include static void girara_toggle_widget_visibility(GtkWidget* widget); static bool simulate_key_press(girara_session_t* session, int state, int key); bool girara_shortcut_add(girara_session_t* session, guint modifier, guint key, const char* buffer, girara_shortcut_function_t function, girara_mode_t mode, int argument_n, void* argument_data) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(buffer || key || modifier, false); g_return_val_if_fail(function != NULL, false); girara_argument_t argument = {argument_n, (argument_data != NULL) ? g_strdup(argument_data) : NULL}; /* search for existing binding */ bool found_existing_shortcut = false; GIRARA_LIST_FOREACH(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcuts_it) if (((shortcuts_it->mask == modifier && shortcuts_it->key == key && (modifier != 0 || key != 0)) || (buffer && shortcuts_it->buffered_command && !strcmp(shortcuts_it->buffered_command, buffer))) && ((shortcuts_it->mode == mode) || (mode == 0))) { if (shortcuts_it->argument.data != NULL) { g_free(shortcuts_it->argument.data); } shortcuts_it->function = function; shortcuts_it->argument = argument; found_existing_shortcut = true; if (mode != 0) { girara_list_iterator_free(iter); return true; } } GIRARA_LIST_FOREACH_END(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcuts_it); if (found_existing_shortcut == true) { return true; } /* add new shortcut */ girara_shortcut_t* shortcut = g_slice_new(girara_shortcut_t); shortcut->mask = modifier; shortcut->key = key; shortcut->buffered_command = g_strdup(buffer); shortcut->function = function; shortcut->mode = mode; shortcut->argument = argument; girara_list_append(session->bindings.shortcuts, shortcut); return true; } bool girara_shortcut_remove(girara_session_t* session, guint modifier, guint key, const char* buffer, girara_mode_t mode) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(buffer || key || modifier, false); /* search for existing binding */ GIRARA_LIST_FOREACH(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcuts_it) if (((shortcuts_it->mask == modifier && shortcuts_it->key == key && (modifier != 0 || key != 0)) || (buffer && shortcuts_it->buffered_command && !strcmp(shortcuts_it->buffered_command, buffer))) && shortcuts_it->mode == mode) { girara_list_remove(session->bindings.shortcuts, shortcuts_it); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.shortcuts, girara_shortcut_t*, iter, shortcuts_it); return false; } void girara_shortcut_free(girara_shortcut_t* shortcut) { g_return_if_fail(shortcut != NULL); g_free(shortcut->buffered_command); g_free(shortcut->argument.data); g_slice_free(girara_shortcut_t, shortcut); } bool girara_inputbar_shortcut_add(girara_session_t* session, guint modifier, guint key, girara_shortcut_function_t function, int argument_n, void* argument_data) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(function != NULL, false); girara_argument_t argument = {argument_n, argument_data}; /* search for existing special command */ GIRARA_LIST_FOREACH(session->bindings.inputbar_shortcuts, girara_inputbar_shortcut_t*, iter, inp_sh_it) if (inp_sh_it->mask == modifier && inp_sh_it->key == key) { inp_sh_it->function = function; inp_sh_it->argument = argument; girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.inputbar_shortcuts, girara_inputbar_shortcut_t*, iter, inp_sh_it); /* create new inputbar shortcut */ girara_inputbar_shortcut_t* inputbar_shortcut = g_slice_new(girara_inputbar_shortcut_t); inputbar_shortcut->mask = modifier; inputbar_shortcut->key = key; inputbar_shortcut->function = function; inputbar_shortcut->argument = argument; girara_list_append(session->bindings.inputbar_shortcuts, inputbar_shortcut); return true; } bool girara_inputbar_shortcut_remove(girara_session_t* session, guint modifier, guint key) { g_return_val_if_fail(session != NULL, false); /* search for existing special command */ GIRARA_LIST_FOREACH(session->bindings.inputbar_shortcuts, girara_inputbar_shortcut_t*, iter, inp_sh_it) if (inp_sh_it->mask == modifier && inp_sh_it->key == key) { girara_list_remove(session->bindings.inputbar_shortcuts, inp_sh_it); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.inputbar_shortcuts, girara_inputbar_shortcut_t*, iter, inp_sh_it); return true; } void girara_inputbar_shortcut_free(girara_inputbar_shortcut_t* inputbar_shortcut) { g_slice_free(girara_inputbar_shortcut_t, inputbar_shortcut); } bool girara_isc_activate(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { girara_callback_inputbar_activate(session->gtk.inputbar_entry, session); return true; } bool girara_isc_abort(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); /* hide completion */ girara_argument_t arg = { GIRARA_HIDE, NULL }; girara_isc_completion(session, &arg, NULL, 0); /* clear inputbar */ gtk_editable_delete_text(GTK_EDITABLE(session->gtk.inputbar_entry), 0, -1); /* grab view */ gtk_widget_grab_focus(GTK_WIDGET(session->gtk.view)); /* hide inputbar */ gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar_dialog)); if (session->global.autohide_inputbar == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.inputbar)); } /* Begin from the last command when navigating through history */ girara_input_history_reset(session->command_history); /* reset custom functions */ session->signals.inputbar_custom_activate = NULL; session->signals.inputbar_custom_key_press_event = NULL; gtk_entry_set_visibility(session->gtk.inputbar_entry, TRUE); return true; } bool girara_isc_string_manipulation(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); gchar *separator = NULL; girara_setting_get(session, "word-separator", &separator); gchar *input = gtk_editable_get_chars(GTK_EDITABLE(session->gtk.inputbar_entry), 0, -1); int length = strlen(input); int pos = gtk_editable_get_position(GTK_EDITABLE(session->gtk.inputbar_entry)); int i; switch (argument->n) { case GIRARA_DELETE_LAST_WORD: if (pos == 1 && (input[0] == ':' || input[0] == '/')) { break; } if (pos == 0) { break; } i = pos - 1; /* remove trailing spaces */ for (; i >= 0 && input[i] == ' '; i--); /* find the beginning of the word */ while ((i == (pos - 1)) || ((i > 0) && !strchr(separator, input[i]))) { i--; } gtk_editable_delete_text(GTK_EDITABLE(session->gtk.inputbar_entry), i + 1, pos); gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), i + 1); break; case GIRARA_DELETE_LAST_CHAR: if (length != 1 && pos == 1 && (input[0] == ':' || input[0] == '/')) { break; } if (length == 1 && pos == 1) { girara_isc_abort(session, argument, NULL, 0); } gtk_editable_delete_text(GTK_EDITABLE(session->gtk.inputbar_entry), pos - 1, pos); break; case GIRARA_DELETE_TO_LINE_START: gtk_editable_delete_text(GTK_EDITABLE(session->gtk.inputbar_entry), 1, pos); break; case GIRARA_NEXT_CHAR: gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), pos + 1); break; case GIRARA_PREVIOUS_CHAR: gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), (pos == 1) ? 1 : pos - 1); break; case GIRARA_DELETE_CURR_CHAR: if (length != 1 && pos == 0 && (input[0] == ':' || input[0] == '/')){ break; } if(length == 1 && pos == 0) { girara_isc_abort(session, argument, NULL, 0); } gtk_editable_delete_text(GTK_EDITABLE(session->gtk.inputbar_entry), pos, pos + 1); break; case GIRARA_DELETE_TO_LINE_END: gtk_editable_delete_text(GTK_EDITABLE(session->gtk.inputbar_entry), pos, length); break; case GIRARA_GOTO_START: gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), 1); break; case GIRARA_GOTO_END: gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), -1); break; } g_free(separator); g_free(input); return false; } bool girara_isc_command_history(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); char* temp = gtk_editable_get_chars(GTK_EDITABLE(session->gtk.inputbar_entry), 0, -1); const char* command = argument->n == GIRARA_NEXT ? girara_input_history_next(session->command_history, temp) : girara_input_history_previous(session->command_history, temp); g_free(temp); if (command != NULL) { gtk_entry_set_text(session->gtk.inputbar_entry, command); gtk_widget_grab_focus(GTK_WIDGET(session->gtk.inputbar_entry)); gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), -1); } return true; } /* default shortcut implementation */ bool girara_sc_focus_inputbar(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->gtk.inputbar_entry != NULL, false); if (gtk_widget_get_visible(GTK_WIDGET(session->gtk.inputbar)) == false) { gtk_widget_show(GTK_WIDGET(session->gtk.inputbar)); } if (gtk_widget_get_visible(GTK_WIDGET(session->gtk.notification_area)) == true) { gtk_widget_hide(GTK_WIDGET(session->gtk.notification_area)); } gtk_widget_grab_focus(GTK_WIDGET(session->gtk.inputbar_entry)); if (argument != NULL && argument->data != NULL) { gtk_entry_set_text(session->gtk.inputbar_entry, (char*) argument->data); /* we save the X clipboard that will be clear by "grab_focus" */ gchar* x_clipboard_text = gtk_clipboard_wait_for_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY)); gtk_editable_set_position(GTK_EDITABLE(session->gtk.inputbar_entry), -1); if (x_clipboard_text != NULL) { /* we reset the X clipboard with saved text */ gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY), x_clipboard_text, -1); g_free(x_clipboard_text); } } return true; } bool girara_sc_abort(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); girara_isc_abort(session, NULL, NULL, 0); gtk_widget_hide(GTK_WIDGET(session->gtk.notification_area)); if (session->global.autohide_inputbar == false) { gtk_widget_show(GTK_WIDGET(session->gtk.inputbar)); } return false; } bool girara_sc_quit(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); girara_argument_t arg = { GIRARA_HIDE, NULL }; girara_isc_completion(session, &arg, NULL, 0); gtk_main_quit(); return false; } bool girara_sc_tab_close(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); girara_tab_t* tab = girara_tab_current_get(session); if (tab != NULL) { girara_tab_remove(session, tab); } return false; } bool girara_sc_tab_navigate(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int t) { g_return_val_if_fail(session != NULL, false); const unsigned int number_of_tabs = girara_get_number_of_tabs(session); if (number_of_tabs == 0) { return false; } unsigned int current_tab = girara_tab_position_get(session, girara_tab_current_get(session)); unsigned int step = (argument->n == GIRARA_PREVIOUS) ? -1 : 1; unsigned int new_tab = (current_tab + step) % number_of_tabs; if (t != 0 && t <= number_of_tabs) { new_tab = t - 1; } girara_tab_t* tab = girara_tab_get(session, new_tab); if (tab != NULL) { girara_tab_current_set(session, tab); } girara_tab_update(session); return false; } bool girara_sc_tab_navigate_next(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t) { argument->n = GIRARA_NEXT; return girara_sc_tab_navigate(session, argument, event, t); } bool girara_sc_tab_navigate_prev(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t) { argument->n = GIRARA_PREVIOUS; return girara_sc_tab_navigate(session, argument, event, t); } static void girara_toggle_widget_visibility(GtkWidget* widget) { if (widget == NULL) { return; } if (gtk_widget_get_visible(widget) == TRUE) { gtk_widget_hide(widget); } else { gtk_widget_show(widget); } } bool girara_sc_toggle_inputbar(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); girara_toggle_widget_visibility(GTK_WIDGET(session->gtk.inputbar)); return true; } bool girara_sc_toggle_statusbar(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); girara_toggle_widget_visibility(GTK_WIDGET(session->gtk.statusbar)); return true; } bool girara_sc_toggle_tabbar(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); girara_toggle_widget_visibility(GTK_WIDGET(session->gtk.tabbar)); return true; } bool girara_sc_set(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); if (argument == NULL || argument->data == NULL) { return false; } /* create argument list */ girara_list_t* argument_list = girara_list_new(); if (argument_list == NULL) { return false; } gchar** argv = NULL; gint argc = 0; girara_list_set_free_function(argument_list, g_free); if (g_shell_parse_argv((const gchar*) argument->data, &argc, &argv, NULL) != FALSE) { for(int i = 0; i < argc; i++) { char* argument = g_strdup(argv[i]); girara_list_append(argument_list, (void*) argument); } } else { girara_list_free(argument_list); return false; } /* call set */ girara_cmd_set(session, argument_list); /* cleanup */ girara_list_free(argument_list); return false; } bool girara_sc_feedkeys(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int t) { if (session == NULL || argument == NULL) { return false; } typedef struct gdk_keyboard_button_s { char* identifier; int keyval; } gdk_keyboard_button_t; static const gdk_keyboard_button_t gdk_keyboard_buttons[] = { {"BackSpace", GDK_KEY_BackSpace}, {"CapsLock", GDK_KEY_Caps_Lock}, {"Down", GDK_KEY_Down}, {"Esc", GDK_KEY_Escape}, {"F10", GDK_KEY_F10}, {"F11", GDK_KEY_F11}, {"F12", GDK_KEY_F12}, {"F1", GDK_KEY_F1}, {"F2", GDK_KEY_F2}, {"F3", GDK_KEY_F3}, {"F4", GDK_KEY_F4}, {"F5", GDK_KEY_F5}, {"F6", GDK_KEY_F6}, {"F7", GDK_KEY_F7}, {"F8", GDK_KEY_F8}, {"F9", GDK_KEY_F9}, {"Left", GDK_KEY_Left}, {"PageDown", GDK_KEY_Page_Down}, {"PageUp", GDK_KEY_Page_Up}, {"Home", GDK_KEY_Home}, {"End", GDK_KEY_End}, {"Return", GDK_KEY_Return}, {"Right", GDK_KEY_Right}, {"Space", GDK_KEY_space}, {"Super", GDK_KEY_Super_L}, {"Tab", GDK_KEY_Tab}, {"ShiftTab", GDK_KEY_ISO_Left_Tab}, {"Up", GDK_KEY_Up} }; char* input = (char*) argument->data; unsigned int input_length = strlen(input); t = (t == 0) ? 1 : t; for (unsigned int c = 0; c < t; c++) { for (unsigned i = 0; i < input_length; i++) { int state = 0; int keyval = input[i]; /* possible special button */ if ((input_length - i) >= 3 && input[i] == '<') { char* end = strchr(input + i, '>'); if (end == NULL) { goto single_key; } int length = end - (input + i) - 1; char* tmp = g_strndup(input + i + 1, length); bool found = false; /* Multi key shortcut */ if (length > 2 && tmp[1] == '-') { switch (tmp[0]) { case 'S': state = GDK_SHIFT_MASK; break; case 'A': state = GDK_MOD1_MASK; break; case 'C': state = GDK_CONTROL_MASK; break; default: break; } if (length == 3) { keyval = tmp[2]; found = true; } else { for (unsigned int i = 0; i < LENGTH(gdk_keyboard_buttons); i++) { if (g_strcmp0(tmp + 2, gdk_keyboard_buttons[i].identifier) == 0) { keyval = gdk_keyboard_buttons[i].keyval; found = true; break; } } } /* Possible special key */ } else { for (unsigned int i = 0; i < LENGTH(gdk_keyboard_buttons); i++) { if (g_strcmp0(tmp, gdk_keyboard_buttons[i].identifier) == 0) { keyval = gdk_keyboard_buttons[i].keyval; found = true; break; } } } g_free(tmp); /* parsed special key */ if (found == true) { i += length + 1; } } single_key: update_state_by_keyval(&state, keyval); simulate_key_press(session, state, keyval); } } return true; } bool girara_shortcut_mapping_add(girara_session_t* session, const char* identifier, girara_shortcut_function_t function) { g_return_val_if_fail(session != NULL, false); if (function == NULL || identifier == NULL) { return false; } GIRARA_LIST_FOREACH(session->config.shortcut_mappings, girara_shortcut_mapping_t*, iter, data) if (strcmp(data->identifier, identifier) == 0) { data->function = function; girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->config.shortcut_mappings, girara_shortcut_mapping_t*, iter, data); /* add new config handle */ girara_shortcut_mapping_t* mapping = g_slice_new(girara_shortcut_mapping_t); mapping->identifier = g_strdup(identifier); mapping->function = function; girara_list_append(session->config.shortcut_mappings, mapping); return true; } void girara_shortcut_mapping_free(girara_shortcut_mapping_t* mapping) { if (mapping == NULL) { return; } g_free(mapping->identifier); g_slice_free(girara_shortcut_mapping_t, mapping); } bool girara_argument_mapping_add(girara_session_t* session, const char* identifier, int value) { g_return_val_if_fail(session != NULL, false); if (identifier == NULL) { return false; } GIRARA_LIST_FOREACH(session->config.argument_mappings, girara_argument_mapping_t*, iter, mapping); if (g_strcmp0(mapping->identifier, identifier) == 0) { mapping->value = value; girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->config.argument_mappings, girara_argument_mapping_t*, iter, mapping); /* add new config handle */ girara_argument_mapping_t* mapping = g_slice_new(girara_argument_mapping_t); mapping->identifier = g_strdup(identifier); mapping->value = value; girara_list_append(session->config.argument_mappings, mapping); return true; } void girara_argument_mapping_free(girara_argument_mapping_t* argument_mapping) { if (argument_mapping == NULL) { return; } g_free(argument_mapping->identifier); g_slice_free(girara_argument_mapping_t, argument_mapping); } bool girara_mouse_event_add(girara_session_t* session, guint mask, guint button, girara_shortcut_function_t function, girara_mode_t mode, girara_event_type_t event_type, int argument_n, void* argument_data) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(function != NULL, false); girara_argument_t argument = {argument_n, argument_data}; /* search for existing binding */ GIRARA_LIST_FOREACH(session->bindings.mouse_events, girara_mouse_event_t*, iter, me_it) if (me_it->mask == mask && me_it->button == button && me_it->mode == mode && me_it->event_type == event_type) { me_it->function = function; me_it->argument = argument; girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.mouse_events, girara_mouse_event_t*, iter, me_it); /* add new mouse event */ girara_mouse_event_t* mouse_event = g_slice_new(girara_mouse_event_t); mouse_event->mask = mask; mouse_event->button = button; mouse_event->function = function; mouse_event->mode = mode; mouse_event->event_type = event_type; mouse_event->argument = argument; girara_list_append(session->bindings.mouse_events, mouse_event); return true; } bool girara_mouse_event_remove(girara_session_t* session, guint mask, guint button, girara_mode_t mode) { g_return_val_if_fail(session != NULL, false); /* search for existing binding */ GIRARA_LIST_FOREACH(session->bindings.mouse_events, girara_mouse_event_t*, iter, me_it) if (me_it->mask == mask && me_it->button == button && me_it->mode == mode) { girara_list_remove(session->bindings.mouse_events, me_it); girara_list_iterator_free(iter); return true; } GIRARA_LIST_FOREACH_END(session->bindings.mouse_events, girara_mouse_event_t*, iter, me_it); return false; } void girara_mouse_event_free(girara_mouse_event_t* mouse_event) { if (mouse_event == NULL) { return; } g_slice_free(girara_mouse_event_t, mouse_event); } static bool simulate_key_press(girara_session_t* session, int state, int key) { if (session == NULL || session->gtk.box == NULL) { return false; } GdkEvent* event = gdk_event_new(GDK_KEY_PRESS); event->key.type = GDK_KEY_PRESS; event->key.window = gtk_widget_get_parent_window(GTK_WIDGET(session->gtk.box)); event->key.send_event = false; event->key.time = GDK_CURRENT_TIME; event->key.state = state; event->key.keyval = key; g_object_ref(event->key.window); GdkKeymapKey* keys; gint number_of_keys; if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), event->key.keyval, &keys, &number_of_keys) == FALSE) { gdk_event_free(event); return false; } event->key.hardware_keycode = keys[0].keycode; event->key.group = keys[0].group; g_free(keys); gdk_event_put(event); gdk_event_free(event); gtk_main_iteration_do(FALSE); return true; } girara-0.2.5/girara/shortcuts.h0000644000175000017500000002407212635750323015116 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_SHORTCUTS_H #define GIRARA_SHORTCUTS_H #include "types.h" #include /** * Adds a shortcut * * Note: currently argument_data accepts only a character string * * @param session The used girara session * @param modifier The modifier * @param key The key * @param buffer Buffer command * @param function Executed function * @param mode Available modes * @param argument_n Argument identifier * @param argument_data Argument data * @return true No error occured * @return false An error occured */ bool girara_shortcut_add(girara_session_t* session, guint modifier, guint key, const char* buffer, girara_shortcut_function_t function, girara_mode_t mode, int argument_n, void* argument_data); /** * Removes a shortcut * * @param session The used girara session * @param modifier The modifier * @param key The key * @param buffer Buffer command * @param mode Available modes * @return true No error occured * @return false An error occured */ bool girara_shortcut_remove(girara_session_t* session, guint modifier, guint key, const char* buffer, girara_mode_t mode); /** * Adds an inputbar shortcut * * @param session The used girara session * @param modifier The modifier * @param key The key * @param function Executed function * @param argument_n Argument identifier * @param argument_data Argument data * @return true No error occured * @return false An error occured */ bool girara_inputbar_shortcut_add(girara_session_t* session, guint modifier, guint key, girara_shortcut_function_t function, int argument_n, void* argument_data); /** * Removes an inputbar shortcut * * @param session The used girara session * @param modifier The modifier * @param key The key * @return true No error occured * @return false An error occured */ bool girara_inputbar_shortcut_remove(girara_session_t* session, guint modifier, guint key); /** * Default shortcut function to focus the inputbar * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_focus_inputbar(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default shortcut function to abort * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_abort(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default shortcut function to quit the application * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_quit(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Closes the current tab * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_tab_close(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default shortcut function to navigate through tabs * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of execution * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_tab_navigate(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Navigate to the next tab * * @param session The used girara session * @param argument The used argument * @param event Girara event * @param t Number of executions * @return true if no error occured otherwise false */ bool girara_sc_tab_navigate_next(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Navigate to the previous tab * * @param session The used girara session * @param argument The used argument * @param event Girara event * @param t Number of executions * @return true if no error occured otherwise false */ bool girara_sc_tab_navigate_prev(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Toggles the visibility of the inputbar * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Numbr of execution * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_toggle_inputbar(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Toggles the visibility of the statusbar * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Numbr of execution * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_toggle_statusbar(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Toggles the visibility of the tabbar * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of execution * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_toggle_tabbar(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Passes the argument to the set command * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number ofexecutions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_sc_set(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default shortcut function to activate * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_isc_activate(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default inputbar shortcut to abort * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_isc_abort(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default inputbar shortcut that completes the given input * in the statusbar * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_isc_completion(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default inputbar shortcut to manipulate the inputbar string * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_isc_string_manipulation(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Default inputbar shortcut to navigate through the command history * * @param session The used girara session * @param argument The argument * @param event Girara event * @param t Number of executions * @return true No error occured * @return false An error occured (abort execution) */ bool girara_isc_command_history(girara_session_t* session, girara_argument_t* argument, girara_event_t* event, unsigned int t); /** * Creates a mapping between a shortcut function and an identifier and is used * to evaluate the mapping command * * @param session The girara session * @param identifier Optional identifier * @param function The function that should be mapped * @return true if no error occured */ bool girara_shortcut_mapping_add(girara_session_t* session, const char* identifier, girara_shortcut_function_t function); /** * Creates a mapping between a shortcut argument and an identifier and is used * to evalue the mapping command * * @param session The girara session * @param identifier The identifier * @param value The value that should be represented * @return true if no error occured */ bool girara_argument_mapping_add(girara_session_t* session, const char* identifier, int value); /** * Adds a mouse event * * @param session The used girara session * @param mask The mask * @param button Pressed button * @param function Executed function * @param mode Available mode * @param event_type Event type * @param argument_n Argument identifier * @param argument_data Argument data * @return true No error occured * @return false An error occured */ bool girara_mouse_event_add(girara_session_t* session, guint mask, guint button, girara_shortcut_function_t function, girara_mode_t mode, girara_event_type_t event_type, int argument_n, void* argument_data); /** * Removes a mouse event * * @param session The used girara session * @param mask The mask * @param button Pressed button * @param mode Available mode * @return true No error occured * @return false An error occured */ bool girara_mouse_event_remove(girara_session_t* session, guint mask, guint button, girara_mode_t mode); #endif girara-0.2.5/girara/statusbar.c0000644000175000017500000000407212513025726015056 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "statusbar.h" #include "session.h" #include "datastructures.h" #include "internal.h" #include "settings.h" girara_statusbar_item_t* girara_statusbar_item_add(girara_session_t* session, bool expand, bool fill, bool left, girara_statusbar_event_t callback) { g_return_val_if_fail(session != NULL && session->elements.statusbar_items, FALSE); girara_statusbar_item_t* item = g_slice_new(girara_statusbar_item_t); item->box = gtk_event_box_new(); item->text = GTK_LABEL(gtk_label_new(NULL)); /* set style */ widget_add_class(GTK_WIDGET(item->box), "statusbar"); widget_add_class(GTK_WIDGET(item->text), "statusbar"); /* set properties */ gtk_widget_set_halign(GTK_WIDGET(item->text), left ? GTK_ALIGN_START : GTK_ALIGN_END); gtk_widget_set_valign(GTK_WIDGET(item->text), GTK_ALIGN_CENTER); gtk_label_set_use_markup(item->text, TRUE); /* add ellipsis if item is on the left side */ if (left == true) { gtk_label_set_ellipsize(item->text, PANGO_ELLIPSIZE_END); } /* add name so it uses a custom style */ gtk_widget_set_name(GTK_WIDGET(item->text), "bottom_box"); if (callback != NULL) { g_signal_connect(G_OBJECT(item->box), "button-press-event", G_CALLBACK(callback), session); } /* add it to the list */ gtk_container_add(GTK_CONTAINER(item->box), GTK_WIDGET(item->text)); gtk_box_pack_start(session->gtk.statusbar_entries, GTK_WIDGET(item->box), expand, fill, 0); gtk_widget_show_all(GTK_WIDGET(item->box)); girara_list_prepend(session->elements.statusbar_items, item); return item; } void girara_statusbar_item_free(girara_statusbar_item_t* item) { g_slice_free(girara_statusbar_item_t, item); } bool girara_statusbar_item_set_text(girara_session_t* session, girara_statusbar_item_t* item, const char* text) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(item != NULL, false); char* escaped_text = g_markup_escape_text(text, -1); gtk_label_set_markup((GtkLabel*) item->text, escaped_text); g_free(escaped_text); return true; } girara-0.2.5/girara/statusbar.h0000644000175000017500000000261012513025726015057 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_STATUSBAR_H #define GIRARA_STATUSBAR_H #include "macros.h" #include "types.h" #include /** * Function declaration for a statusbar event callback * * @param widget The statusbar item * @param event The occured event * @param session The current girara session * @return TRUE No error occured * @return FALSE Error occured (and forward event) */ typedef bool (*girara_statusbar_event_t)(GtkWidget* widget, GdkEvent* event, girara_session_t* session); /** * Creates an statusbar item * * @param session The used girara session * @param expand Expand attribute * @param fill Fill attribute * @param left True if it should be aligned to the left * @param callback Function that gets executed when an event occurs * @return The created statusbar item * @return NULL An error occured */ girara_statusbar_item_t* girara_statusbar_item_add(girara_session_t* session, bool expand, bool fill, bool left, girara_statusbar_event_t callback); /** * Sets the shown text of an statusbar item * * @param session The used girara session * @param item The statusbar item * @param text Text that should be displayed * @return TRUE No error occured * @return FALSE An error occured */ bool girara_statusbar_item_set_text(girara_session_t* session, girara_statusbar_item_t* item, const char* text); #endif girara-0.2.5/girara/tabs.c0000644000175000017500000001564112513025726014003 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "tabs.h" #include "session.h" #include "internal.h" #define UNTITLED_TAB_TITLE "untitled" /** * Default implementation of the event that is executed if a tab is clicked * * @param widget The widget * @param event The event * @param data Additional data * @return true if an error occurred, otherwise false */ static bool girara_callback_tab_clicked(GtkWidget* widget, GdkEventButton* event, gpointer data); void girara_tabs_enable(girara_session_t* session) { if (session == NULL || session->gtk.tabs == NULL) { return; } /* Display tab view */ girara_set_view(session, GTK_WIDGET(session->gtk.tabs)); /* Display tab bar */ if (session->gtk.tabbar) { gtk_widget_show(session->gtk.tabbar); } } girara_tab_t* girara_tab_new(girara_session_t* session, const char* title, GtkWidget* widget, bool next_to_current, void* data) { if (session == NULL || widget == NULL) { return NULL; } girara_tab_t* tab = g_slice_new(girara_tab_t); tab->title = title ? g_strdup(title) : g_strdup(UNTITLED_TAB_TITLE); tab->widget = widget; tab->session = session; tab->data = data; int position = (next_to_current) ? (gtk_notebook_get_current_page(session->gtk.tabs) + 1) : -1; /* insert tab into notebook */ if (gtk_notebook_insert_page(session->gtk.tabs, tab->widget, NULL, position) == -1) { g_free(tab->title); g_slice_free(girara_tab_t, tab); return NULL; } /* create tab label */ GtkWidget *tab_label = gtk_label_new(tab->title); GtkWidget *tab_event = gtk_event_box_new(); g_object_set_data(G_OBJECT(tab->widget), "event", (gpointer) tab_event); g_object_set_data(G_OBJECT(tab->widget), "label", (gpointer) tab_label); g_object_set_data(G_OBJECT(tab->widget), "tab", (gpointer) tab); g_signal_connect(G_OBJECT(tab_event), "button_press_event", G_CALLBACK(girara_callback_tab_clicked), tab); gtk_widget_set_halign(tab_label, GTK_ALIGN_START); gtk_widget_set_valign(tab_label, GTK_ALIGN_START); widget_add_class(tab_label, "tab"); widget_add_class(tab_event, "tab"); gtk_label_set_ellipsize(GTK_LABEL(tab_label), PANGO_ELLIPSIZE_MIDDLE); gtk_container_add(GTK_CONTAINER(tab_event), tab_label); gtk_box_pack_start(GTK_BOX(session->gtk.tabbar), tab_event, TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(session->gtk.tabbar), tab_event, position); gtk_widget_show_all(widget); gtk_widget_show_all(tab_event); gtk_notebook_set_current_page(session->gtk.tabs, position); girara_tab_update(session); return tab; } void girara_tab_remove(girara_session_t* session, girara_tab_t* tab) { if (session == NULL || tab == NULL || session->gtk.tabbar == NULL) { return; } /* Remove page from notebook */ int tab_id = girara_tab_position_get(session, tab); /* Remove entry from tabbar */ GtkWidget* tab_event = GTK_WIDGET(g_object_get_data(G_OBJECT(tab->widget), "event")); if (tab_event != NULL) { gtk_container_remove(GTK_CONTAINER(session->gtk.tabbar), tab_event); } if (tab_id != -1) { gtk_notebook_remove_page(session->gtk.tabs, tab_id); } g_free(tab->title); g_slice_free(girara_tab_t, tab); girara_tab_update(session); } girara_tab_t* girara_tab_get(girara_session_t* session, unsigned int index) { if (session == NULL || session->gtk.tabs == NULL) { return 0; } GtkWidget* widget = gtk_notebook_get_nth_page(session->gtk.tabs, index); return (girara_tab_t*) g_object_get_data(G_OBJECT(widget), "tab"); } int girara_get_number_of_tabs(girara_session_t* session) { if (session == NULL || session->gtk.tabs == NULL) { return 0; } return gtk_notebook_get_n_pages(session->gtk.tabs); } void girara_tab_update(girara_session_t* session) { if (session == NULL || session->gtk.tabs == NULL) { return; } int number_of_tabs = girara_get_number_of_tabs(session); int current_tab = girara_tab_position_get(session, girara_tab_current_get(session)); for (int i = 0; i < number_of_tabs; i++) { GtkWidget* widget = gtk_notebook_get_nth_page(session->gtk.tabs, i); girara_tab_t* tab = (girara_tab_t*) g_object_get_data(G_OBJECT(widget), "tab"); if (tab == NULL) { continue; } GtkWidget* tab_event = GTK_WIDGET(g_object_get_data(G_OBJECT(tab->widget), "event")); GtkWidget* tab_label = GTK_WIDGET(g_object_get_data(G_OBJECT(tab->widget), "label")); if (i == current_tab) { gtk_widget_set_state_flags(tab_event, GTK_STATE_FLAG_SELECTED, false); gtk_widget_set_state_flags(tab_label, GTK_STATE_FLAG_SELECTED, false); } else { gtk_widget_unset_state_flags(tab_event, GTK_STATE_FLAG_SELECTED); gtk_widget_unset_state_flags(tab_label, GTK_STATE_FLAG_SELECTED); } } } girara_tab_t* girara_tab_current_get(girara_session_t* session) { if (session == NULL || session->gtk.tabs == NULL) { return NULL; } int current = gtk_notebook_get_current_page(session->gtk.tabs); if (current != -1) { GtkWidget* widget = gtk_notebook_get_nth_page(session->gtk.tabs, current); return (girara_tab_t*) g_object_get_data(G_OBJECT(widget), "tab"); } else { return NULL; } } void girara_tab_current_set(girara_session_t* session, girara_tab_t* tab) { if (session == NULL || session->gtk.tabs == NULL || tab == NULL || tab->widget == NULL) { return; } int index = gtk_notebook_page_num(session->gtk.tabs, tab->widget); if (index != -1) { gtk_notebook_set_current_page(session->gtk.tabs, index); } girara_tab_update(session); } void girara_tab_title_set(girara_tab_t* tab, const char* title) { if (tab == NULL) { return; } g_free(tab->title); tab->title = title ? g_strdup(title) : g_strdup(UNTITLED_TAB_TITLE); GtkWidget* tab_label = GTK_WIDGET(g_object_get_data(G_OBJECT(tab->widget), "label")); if (tab_label) { gtk_label_set_text(GTK_LABEL(tab_label), tab->title); } } const char* girara_tab_title_get(girara_tab_t* tab) { if (tab == NULL) { return NULL; } return tab->title; } int girara_tab_position_get(girara_session_t* session, girara_tab_t* tab) { if (session == NULL || session->gtk.tabs == NULL || tab == NULL || tab->widget == NULL) { return -1; } return gtk_notebook_page_num(session->gtk.tabs, tab->widget); } void girara_tab_position_set(girara_session_t* session, girara_tab_t* tab, unsigned int position) { if (session == NULL || session->gtk.tabs == NULL || tab == NULL || tab->widget == NULL) { return; } gtk_notebook_reorder_child(session->gtk.tabs, tab->widget, position); } static bool girara_callback_tab_clicked(GtkWidget* UNUSED(widget), GdkEventButton* event, gpointer data) { if (data == NULL) { return false; } girara_tab_t* tab = (girara_tab_t*) data; girara_session_t* session = tab->session; switch (event->button) { case 1: girara_tab_current_set(session, tab); break; case 2: girara_tab_remove(session, tab); break; } return true; } girara-0.2.5/girara/tabs.h0000644000175000017500000000601612513025726014004 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_TABS_H #define GIRARA_TABS_H #include "types.h" #include /** * Structure of a tab */ struct girara_tab_s { char* title; /**< The title of the tab */ GtkWidget* widget; /**< The displayed widget of the tab */ void* data; /**< Custom data */ girara_session_t* session; /**< Girara session */ }; /** * Enables the tab view. If girara_set_view is used, the tab bar will * automatically vanish and girara_tabs_enable has to be called another time to * re-enable it again. * * @param session The girara session */ void girara_tabs_enable(girara_session_t* session); /** * Creates and adds a new tab to the tab view * * @param session The girara session * @param title Title of the tab (optional) * @param widget Displayed widget * @param next_to_current Tab should be created right next to the current one * @param data Custom data * @return A new tab object or NULL if an error occured */ girara_tab_t* girara_tab_new(girara_session_t* session, const char* title, GtkWidget* widget, bool next_to_current, void* data); /** * Removes and destroys a tab from the tab view * * @param session The girara session * @param tab Tab */ void girara_tab_remove(girara_session_t* session, girara_tab_t* tab); /** * Returns the tab at the given index * * @param session The girara session * @param index Index of the tab * @return The tab object or NULL if an error occured */ girara_tab_t* girara_tab_get(girara_session_t* session, unsigned int index); /** * Returns the number of tabs * * @param session The girara session * @return The number of tabs */ int girara_get_number_of_tabs(girara_session_t* session); /** * Updates the color and states of all tabs * * @param session The girara session */ void girara_tab_update(girara_session_t* session); /** * Returns the current tab * * @param session The girara session * @return The current tab or NULL if an error occured */ girara_tab_t* girara_tab_current_get(girara_session_t* session); /** * Sets the current tab * * @param session The girara session * @param tab The new current tab */ void girara_tab_current_set(girara_session_t* session, girara_tab_t* tab); /** * Sets the shown title of the tab * * @param tab The tab * @param title The new title */ void girara_tab_title_set(girara_tab_t* tab, const char* title); /** * Returns the title of the tab * * @param tab The tab * @return The title of the tab or NULL if an error occured */ const char* girara_tab_title_get(girara_tab_t* tab); /** * Returns the position of the tab * * @param session Girara session * @param tab The tab * @return The id of the tab or -1 if an error occured */ int girara_tab_position_get(girara_session_t* session, girara_tab_t* tab); /** * Sets the new position of the tab * * @param session Girara session * @param tab The tab * @param position The new position */ void girara_tab_position_set(girara_session_t* session, girara_tab_t* tab, unsigned int position); #endif girara-0.2.5/girara/template.c0000644000175000017500000002604312513025726014663 0ustar mockmock/* See LICENSE file for license and copyright information */ #include "template.h" #include "utils.h" #include "datastructures.h" #include G_DEFINE_TYPE(GiraraTemplate, girara_template, G_TYPE_OBJECT) /** * Private data of the template */ typedef struct private_s { char* base; GRegex* variable_regex; GRegex* variable_check_regex; girara_list_t* variables_in_base; girara_list_t* variables; bool valid; } private_t; typedef struct private_s GiraraTemplatePrivate; #define GET_PRIVATE(obj) \ (G_TYPE_INSTANCE_GET_PRIVATE((obj), GIRARA_TYPE_TEMPLATE, private_t)) /** * Internal variables */ typedef struct variable_s { char* name; char* value; } variable_t; static variable_t* new_variable(const char* name) { if (name == NULL) { return NULL; } variable_t* variable = g_try_malloc0(sizeof(variable_t)); if (variable == NULL) { return NULL; } variable->name = g_strdup(name); variable->value = g_strdup(""); return variable; } static void free_variable(void* data) { variable_t* variable = data; g_free(variable->name); g_free(variable->value); variable->name = NULL; variable->value = NULL; g_free(variable); } static int compare_variable_name(const void* data1, const void* data2) { const variable_t* variable = data1; const char* name = data2; if (variable == NULL) { return -1; } return g_strcmp0(variable->name, name); } /* Methods */ static void dispose(GObject* object); static void finalize(GObject* object); static void set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec); static void get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec); static void base_changed(GiraraTemplate* object); static void variable_changed(GiraraTemplate* object, const char* name); static void template_changed(GiraraTemplate* object); /* Properties */ enum { PROP_0, PROP_BASE }; /* Signals */ enum { BASE_CHANGED, VARIABLE_CHANGED, TEMPLATE_CHANGED, LAST_SIGNAL }; static guint signals[LAST_SIGNAL] = { 0 }; /* Class init */ static void girara_template_class_init(GiraraTemplateClass* class) { /* add private members */ g_type_class_add_private(class, sizeof(private_t)); /* overwrite methods */ GObjectClass* object_class = G_OBJECT_CLASS(class); object_class->dispose = dispose; object_class->finalize = finalize; object_class->set_property = set_property; object_class->get_property = get_property; class->base_changed = base_changed; class->variable_changed = variable_changed; class->changed = template_changed; /* add properties */ g_object_class_install_property(object_class, PROP_BASE, g_param_spec_object("base", "base template", "String used as base for the template.", girara_template_get_type(), G_PARAM_WRITABLE | G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /* add signals */ signals[BASE_CHANGED] = g_signal_new("base-changed", GIRARA_TYPE_TEMPLATE, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET(GiraraTemplateClass, base_changed), NULL, NULL, NULL, G_TYPE_NONE, 0); signals[VARIABLE_CHANGED] = g_signal_new("variable-changed", GIRARA_TYPE_TEMPLATE, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET(GiraraTemplateClass, variable_changed), NULL, NULL, NULL, G_TYPE_NONE, 1, G_TYPE_STRING); signals[TEMPLATE_CHANGED] = g_signal_new("changed", GIRARA_TYPE_TEMPLATE, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET(GiraraTemplateClass, changed), NULL, NULL, NULL, G_TYPE_NONE, 0); } /* GObject init */ static void girara_template_init(GiraraTemplate* history) { GError* error = NULL; GRegex* regex = g_regex_new("@([A-Za-z0-9][A-Za-z0-9_-]*)@", G_REGEX_OPTIMIZE, 0, &error); if (regex == NULL) { girara_error("Failed to create regex: %s", error->message); g_error_free(error); } GRegex* check_regex = g_regex_new("^[A-Za-z0-9][A-Za-z0-9_-]*$", G_REGEX_OPTIMIZE, 0, &error); if (check_regex == NULL) { girara_error("Failed to create regex: %s", error->message); g_regex_unref(regex); g_error_free(error); } private_t* priv = GET_PRIVATE(history); priv->base = g_strdup(""); priv->variable_regex = regex; priv->variable_check_regex = check_regex; priv->variables_in_base = girara_list_new2(g_free); priv->variables = girara_list_new2(free_variable); priv->valid = true; } /* GObject dispose */ static void dispose(GObject* object) { private_t* priv = GET_PRIVATE(object); g_regex_unref(priv->variable_regex); g_regex_unref(priv->variable_check_regex); priv->variable_regex = NULL; priv->variable_check_regex = NULL; G_OBJECT_CLASS(girara_template_parent_class)->dispose(object); } /* GObject finalize */ static void finalize(GObject* object) { private_t* priv = GET_PRIVATE(object); g_free(priv->base); girara_list_free(priv->variables_in_base); girara_list_free(priv->variables); priv->base = NULL; priv->variables_in_base = NULL; priv->variables = NULL; G_OBJECT_CLASS(girara_template_parent_class)->finalize(object); } /* GObject set_property */ static void set_property(GObject* obj, guint prop_id, const GValue* value, GParamSpec* pspec) { GiraraTemplate* object = GIRARA_TEMPLATE(obj); switch (prop_id) { case PROP_BASE: { girara_template_set_base(object, g_value_get_string(value)); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, pspec); } } /* GObject get_property */ static void get_property(GObject* obj, guint prop_id, GValue* value, GParamSpec* pspec) { GiraraTemplate* object = GIRARA_TEMPLATE(obj); switch (prop_id) { case PROP_BASE: g_value_set_string(value, girara_template_get_base(object)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, pspec); } } /* Object new */ GiraraTemplate* girara_template_new(const char* base) { GObject* obj = g_object_new(GIRARA_TYPE_TEMPLATE, NULL); g_return_val_if_fail(obj, NULL); if (obj == NULL) { return NULL; } GiraraTemplate* object = GIRARA_TEMPLATE(obj); if (base != NULL) { girara_template_set_base(object, base); } return object; } void girara_template_set_base(GiraraTemplate* object, const char* base) { g_return_if_fail(GIRARA_IS_TEMPLATE(object)); private_t* priv = GET_PRIVATE(object); if (g_strcmp0(base, priv->base) != 0) { g_free(priv->base); priv->base = g_strdup(base != NULL ? base : ""); g_signal_emit(object, signals[BASE_CHANGED], 0); g_signal_emit(object, signals[TEMPLATE_CHANGED], 0); } } const char* girara_template_get_base(GiraraTemplate* object) { g_return_val_if_fail(GIRARA_IS_TEMPLATE(object), NULL); private_t* priv = GET_PRIVATE(object); return priv->base; } static void base_changed(GiraraTemplate* object) { private_t* priv = GET_PRIVATE(object); girara_list_clear(priv->variables_in_base); priv->valid = true; GMatchInfo* match_info = NULL; if (g_regex_match(priv->variable_regex, priv->base, 0, &match_info) == true) { while (g_match_info_matches(match_info) == true) { char* variable = g_match_info_fetch(match_info, 1); char* found = girara_list_find(priv->variables_in_base, (girara_compare_function_t)g_strcmp0, variable); if (priv->valid == true) { if (girara_list_find(priv->variables, compare_variable_name, variable) == NULL) { priv->valid = false; } } if (found == NULL) { girara_list_append(priv->variables_in_base, variable); } else { g_free(variable); } g_match_info_next(match_info, NULL); } } g_match_info_free(match_info); } static void variable_changed(GiraraTemplate* object, const char* GIRARA_UNUSED(name)) { private_t* priv = GET_PRIVATE(object); priv->valid = true; GIRARA_LIST_FOREACH(priv->variables_in_base, char*, iter, variable) if (priv->valid == true && girara_list_find(priv->variables, compare_variable_name, variable) == NULL) { priv->valid = false; } GIRARA_LIST_FOREACH_END(priv->variables_in_base, char*, iter, variable); } static void template_changed(GiraraTemplate* GIRARA_UNUSED(object)) { } girara_list_t* girara_template_referenced_variables(GiraraTemplate* object) { g_return_val_if_fail(GIRARA_IS_TEMPLATE(object), NULL); private_t* priv = GET_PRIVATE(object); return priv->variables_in_base; } bool girara_template_add_variable(GiraraTemplate* object, const char* name) { g_return_val_if_fail(GIRARA_IS_TEMPLATE(object), false); g_return_val_if_fail(name != NULL, false); private_t* priv = GET_PRIVATE(object); if (g_regex_match(priv->variable_check_regex, name, 0, NULL) == FALSE) { girara_debug("'%s' is not a valid variable name.", name); return false; } variable_t* variable = girara_list_find(priv->variables, compare_variable_name, name); if (variable != NULL) { girara_debug("Variable '%s' already exists.", name); return false; } variable = new_variable(name); if (variable == NULL) { girara_debug("Could not create new variable."); return false; } girara_list_append(priv->variables, variable); g_signal_emit(object, signals[VARIABLE_CHANGED], 0, name); g_signal_emit(object, signals[TEMPLATE_CHANGED], 0); return true; } void girara_template_set_variable_value(GiraraTemplate* object, const char* name, const char* value) { g_return_if_fail(GIRARA_IS_TEMPLATE(object)); g_return_if_fail(name != NULL); g_return_if_fail(value != NULL); private_t* priv = GET_PRIVATE(object); variable_t* variable = girara_list_find(priv->variables, compare_variable_name, name); if (variable == NULL) { girara_error("Variable '%s' does not exist.", name); return; } if (g_strcmp0(variable->value, value) != 0) { g_free(variable->value); variable->value = g_strdup(value); g_signal_emit(object, signals[VARIABLE_CHANGED], 0, name); g_signal_emit(object, signals[TEMPLATE_CHANGED], 0); } } static gboolean eval_replace_cb(const GMatchInfo* info, GString* res, void* data) { girara_list_t* variables = data; char* name = g_match_info_fetch(info, 1); variable_t* variable = girara_list_find(variables, compare_variable_name, name); g_return_val_if_fail(variable != NULL, TRUE); g_string_append(res, variable->value); g_free(name); return FALSE; } char* girara_template_evaluate(GiraraTemplate* object) { g_return_val_if_fail(GIRARA_IS_TEMPLATE(object), NULL); private_t* priv = GET_PRIVATE(object); if (priv->valid == false) { girara_error("Base contains variables that do not have a value assigned."); return NULL; } return g_regex_replace_eval(priv->variable_regex, priv->base, -1, 0, 0, eval_replace_cb, priv->variables, NULL); } girara-0.2.5/girara/template.h0000644000175000017500000000521512513025726014666 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_TEMPLATE_H #define GIRARA_TEMPLATE_H #include #include "types.h" struct girara_template_s { GObject parent; }; struct girara_template_class_s { GObjectClass parent_class; void (*base_changed)(GiraraTemplate*); void (*variable_changed)(GiraraTemplate*, const char* name); void (*changed)(GiraraTemplate*); }; #define GIRARA_TYPE_TEMPLATE \ (girara_template_get_type()) #define GIRARA_TEMPLATE(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj), GIRARA_TYPE_TEMPLATE, GiraraTemplate)) #define GIRARA_TEMPLATE_CLASS(obj) \ (G_TYPE_CHECK_CLASS_CAST((obj), GIRARA_TYPE_TEMPLATE, GiraraTemplateClass)) #define GIRARA_IS_TEMPLATE(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GIRARA_TYPE_TEMPLATE)) #define GIRARA_IS_TEMPLATE_CLASS(obj) \ (G_TYPE_CHECK_CLASS_TYPE((obj), GIRARA_TYPE_TEMPLATE)) #define GIRARA_TEMPLATE_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS((obj), GIRARA_TYPE_TEMPLATE, GiraraTemplateClass)) /** * Returns the type of the template. * * @return the type */ GType girara_template_get_type(void); /** * Create new template object. * * @param base a string that is used as template * @returns a templot object */ GiraraTemplate* girara_template_new(const char* base); /** * Set the base string of the template. * * @param object GiraraTemplate object * @param base a string that is used as template */ void girara_template_set_base(GiraraTemplate* object, const char* base); /** * Get the base string of the template. * * @param object GiraraTemplate object * @returns string that is used as template */ const char* girara_template_get_base(GiraraTemplate* object); /** * Get list of variable names referenced in the template. * * @param object GiraraTemplate object * @returns list of variables names referenced in the template */ girara_list_t* girara_template_referenced_variables(GiraraTemplate* object); /** * Register a variable. * * @param object GiraraTemplate object * @param name name of the variable * @returns true if the variable was added, false otherwise */ bool girara_template_add_variable(GiraraTemplate* object, const char* name); /** * Set value of a variable. * * @param object GiraraTemplate object * @param name name of the variable * @param value value of the variable */ void girara_template_set_variable_value(GiraraTemplate* object, const char* name, const char* value); /** * Replace all variables with their values in the template. * * @param object GiraraTemplate object * @returns evaluated template, needes to be deallocated with g_free */ char* girara_template_evaluate(GiraraTemplate* object); #endif girara-0.2.5/girara/types.h0000644000175000017500000001703112513025726014216 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_TYPES_H #define GIRARA_TYPES_H #include "version.h" #include typedef struct girara_tree_node_s girara_tree_node_t; typedef struct girara_list_s girara_list_t; typedef struct girara_list_iterator_s girara_list_iterator_t; typedef struct girara_setting_s girara_setting_t; typedef struct girara_session_s girara_session_t; typedef struct girara_session_private_s girara_session_private_t; typedef struct girara_command_s girara_command_t; typedef struct girara_mouse_event_s girara_mouse_event_t; typedef struct girara_config_handle_s girara_config_handle_t; typedef struct girara_mode_string_s girara_mode_string_t; typedef struct girara_tab_s girara_tab_t; typedef struct girara_statusbar_item_s girara_statusbar_item_t; typedef struct girara_argument_s girara_argument_t; typedef struct girara_shortcut_mapping_s girara_shortcut_mapping_t; typedef struct girara_argument_mapping_s girara_argument_mapping_t; typedef struct girara_completion_element_s girara_completion_element_t; typedef struct girara_completion_s girara_completion_t; typedef struct girara_completion_group_s girara_completion_group_t; typedef struct girara_shortcut_s girara_shortcut_t; typedef struct girara_inputbar_shortcut_s girara_inputbar_shortcut_t; typedef struct girara_special_command_s girara_special_command_t; typedef struct girara_event_s girara_event_t; /** * This structure defines the possible argument identifiers */ enum { GIRARA_HIDE = 1, /**< Hide the completion list */ GIRARA_NEXT, /**< Next entry */ GIRARA_PREVIOUS, /**< Previous entry */ GIRARA_NEXT_GROUP, /**< Next group in the completion list */ GIRARA_PREVIOUS_GROUP, /**< Previous group in the completion list */ GIRARA_HIGHLIGHT, /**< Highlight the entry */ GIRARA_NORMAL, /**< Set to the normal state */ GIRARA_DELETE_LAST_WORD, /**< Delete the last word */ GIRARA_DELETE_LAST_CHAR, /**< Delete the last character */ GIRARA_NEXT_CHAR, /**< Go to the next character */ GIRARA_PREVIOUS_CHAR, /**< Go to the previous character */ GIRARA_DELETE_TO_LINE_START, /**< Delete the line to the start */ GIRARA_DELETE_TO_LINE_END, /**< Delete the line to the end */ GIRARA_DELETE_CURR_CHAR, /**< Delete current char */ GIRARA_GOTO_START, /**< Go to start of the line */ GIRARA_GOTO_END /**< Go to end of the line */ }; /** * Debug levels */ typedef enum girara_debug_level_e { GIRARA_DEBUG, /**> Debug messages */ GIRARA_INFO, /**> Information debug output */ GIRARA_WARNING, /**> Warning level */ GIRARA_ERROR /**> Error */ } girara_debug_level_t; /** * Mode identifier */ typedef int girara_mode_t; /** * Function declaration of a function that generates a completion group * * @param session The current girara session * @param input The current input * @return The completion group */ typedef girara_completion_t* (*girara_completion_function_t)( girara_session_t* session, const char* input); /** * Function declaration of a inputbar special function * * @param session The current girara session * @param input The current input * @param argument The given argument * @return TRUE No error occured * @return FALSE Error occured */ typedef bool (*girara_inputbar_special_function_t)(girara_session_t* session, const char* input, girara_argument_t* argument); /** * Function declaration of a command function * * @param session The current girara session * @param argc Number of arguments * @param argv Arguments */ typedef bool (*girara_command_function_t)(girara_session_t* session, girara_list_t* argument_list); /** * Function declaration of a shortcut function * * If a numeric value has been written into the buffer, this function gets as * often executed as the value defines or until the function returns false the * first time. */ typedef bool (*girara_shortcut_function_t)(girara_session_t*, girara_argument_t*, girara_event_t*, unsigned int); /** * Function declaration of a function that frees something. * * @param data the data to be freed. */ typedef void (*girara_free_function_t)(void* data); /** Function declaration of a function called as callback from girara_list_* * functions. * * @param data a list element. * @param userdata data passed as userdata to the calling function. */ typedef void (*girara_list_callback_t)(void* data, void* userdata); /** Function declaration of a function which compares two elements. * * @param data1 the first element. * @param data2 the second element. * @return -1 if data1 < data2, 0 if data1 == data2 and 1 if data1 > data2 */ typedef int (*girara_compare_function_t)(const void* data1, const void* data2); /** * This structure defines the possible types that a setting value can have */ typedef enum girara_setting_type_e { BOOLEAN, /**< Boolean type */ FLOAT, /**< Floating number */ INT, /**< Integer */ STRING, /**< String */ UNKNOWN = 0xFFFF /**< Unknown type */ } girara_setting_type_t; /** * Function declaration for a settings callback * * @param session The current girara session * @param name The name of the affected settting * @param type The type of the affected setting * @param value Pointer to the new value * @param data User data */ typedef void (*girara_setting_callback_t)(girara_session_t* session, const char* name, girara_setting_type_t type, void* value, void* data); /** * Definition of an argument of a shortcut or buffered command */ struct girara_argument_s { int n; /**< Identifier */ void *data; /**< Data */ }; /** * Define mouse buttons */ typedef enum girara_mouse_button_e { GIRARA_MOUSE_BUTTON1 = 1, /**< Button 1 */ GIRARA_MOUSE_BUTTON2 = 2, /**< Button 2 */ GIRARA_MOUSE_BUTTON3 = 3, /**< Button 3 */ GIRARA_MOUSE_BUTTON4 = 4, /**< Button 4 */ GIRARA_MOUSE_BUTTON5 = 5, /**< Button 5 */ GIRARA_MOUSE_BUTTON6 = 6, /**< Button 6 */ GIRARA_MOUSE_BUTTON7 = 7, /**< Button 7 */ GIRARA_MOUSE_BUTTON8 = 8, /**< Button 8 */ GIRARA_MOUSE_BUTTON9 = 9 /**< Button 9 */ } girara_mouse_button_t; /** * Describes the types of a girara */ typedef enum girara_event_type_e { GIRARA_EVENT_BUTTON_PRESS, /**< Single click */ GIRARA_EVENT_2BUTTON_PRESS, /**< Double click */ GIRARA_EVENT_3BUTTON_PRESS, /**< Triple click */ GIRARA_EVENT_BUTTON_RELEASE, /**< Button released */ GIRARA_EVENT_MOTION_NOTIFY, /**< Cursor moved */ GIRARA_EVENT_SCROLL_UP, /**< Scroll event */ GIRARA_EVENT_SCROLL_DOWN, /**< Scroll event */ GIRARA_EVENT_SCROLL_LEFT, /**< Scroll event */ GIRARA_EVENT_SCROLL_RIGHT, /**< Scroll event */ GIRARA_EVENT_OTHER, /**< Unknown event */ GIRARA_EVENT_SCROLL_BIDIRECTIONAL /**< Scroll event that carries extra data * in girara_argument_t with motion * information as double[2]. * First component is horizontal shift, * second - vertical. */ } girara_event_type_t; /** * Describes a girara event */ struct girara_event_s { girara_event_type_t type; /**< The event type */ double x; /**< X coordinates where the event occured */ double y; /**< Y coordinates where the event occured */ }; typedef struct girara_input_history_io_s GiraraInputHistoryIO; typedef struct girara_input_history_io_interface_s GiraraInputHistoryIOInterface; typedef struct girara_input_history_s GiraraInputHistory; typedef struct girara_input_history_class_s GiraraInputHistoryClass; typedef struct girara_template_s GiraraTemplate; typedef struct girara_template_class_s GiraraTemplateClass; #endif girara-0.2.5/girara/utils.c0000644000175000017500000002533512635750323014216 0ustar mockmock/* See LICENSE file for license and copyright information */ #define _DEFAULT_SOURCE #if !defined(__OpenBSD__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__APPLE__) #define _XOPEN_SOURCE 700 #endif #include #include #include #include #include #include #include #include #include #include #include #include #include "utils.h" #include "datastructures.h" #include "session.h" #include "settings.h" #define BLOCK_SIZE 64 char* girara_fix_path(const char* path) { if (path == NULL) { return NULL; } char* rpath = NULL; if (path[0] == '~') { const size_t len = strlen(path); char* user = NULL; size_t idx = 1; if (len > 1 && path[1] != '/') { while (path[idx] && path[idx] != '/') { ++idx; } user = g_strndup(path + 1, idx - 1); } char* home_path = girara_get_home_directory(user); g_free(user); if (home_path == NULL) { return g_strdup(path); } rpath = g_build_filename(home_path, path + idx, NULL); g_free(home_path); } else { rpath = g_strdup(path); } return rpath; } bool girara_xdg_open(const char* uri) { if (uri == NULL || strlen(uri) == 0) { return false; } /* g_spawn_async expects char** */ char* argv[] = { g_strdup("xdg-open"), g_strdup(uri), NULL }; GError* error = NULL; const bool res = g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &error); if (error != NULL) { girara_warning("Failed to execute command: %s", error->message); g_error_free(error); } g_free(argv[0]); g_free(argv[1]); return res; } char* girara_get_home_directory(const char* user) { if (user == NULL || g_strcmp0(user, g_get_user_name()) == 0) { #if GLIB_CHECK_VERSION(2, 35, 3) return g_strdup(g_get_home_dir()); #else const char* homedir = g_getenv("HOME"); return g_strdup(homedir ? homedir : g_get_home_dir()); #endif } // XXX: The following code is very unportable. struct passwd pwd; struct passwd* result = NULL; #ifdef _SC_GETPW_R_SIZE_MAX int bufsize = sysconf(_SC_GETPW_R_SIZE_MAX); if (bufsize < 0) { bufsize = 4096; } #else int bufsize = 4096; #endif char* buffer = g_try_malloc0(sizeof(char) * bufsize); if (buffer == NULL) { return NULL; } getpwnam_r(user, &pwd, buffer, bufsize, &result); if (result == NULL) { g_free(buffer); return NULL; } char* dir = g_strdup(pwd.pw_dir); g_free(buffer); return dir; } char* girara_get_xdg_path(girara_xdg_path_t path) { static const char* VARS[] = { "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CONFIG_DIRS", "XDG_DATA_DIRS", "XDG_CACHE_HOME", }; static const char* DEFAULTS[] = { "NOTUSED", "NOTUSED", "/etc/xdg", "/usr/local/share/:/usr/share", "NOTUSED" }; switch (path) { case XDG_DATA: return g_strdup(g_get_user_data_dir()); case XDG_CONFIG: return g_strdup(g_get_user_config_dir()); case XDG_CONFIG_DIRS: case XDG_DATA_DIRS: { const char* tmp = g_getenv(VARS[path]); if (tmp == NULL || !g_strcmp0(tmp, "")) { return g_strdup(DEFAULTS[path]); } return g_strdup(tmp); } case XDG_CACHE: return g_strdup(g_get_user_cache_dir()); } return NULL; } girara_list_t* girara_split_path_array(const char* patharray) { if (patharray == NULL || !g_strcmp0(patharray, "")) { return NULL; } girara_list_t* res = girara_list_new2(g_free); char** paths = g_strsplit(patharray, ":", 0); for (size_t i = 0; paths[i] != NULL; ++i) { girara_list_append(res, g_strdup(paths[i])); } g_strfreev(paths); return res; } FILE* girara_file_open(const char* path, const char* mode) { char* fixed_path = girara_fix_path(path); if (fixed_path == NULL || mode == NULL) { return NULL; } FILE* fp = fopen(fixed_path, mode); g_free(fixed_path); if (fp == NULL) { return NULL; } return fp; /* TODO */ /*FILE* fp;*/ /*struct stat lstat;*/ /*struct stat fstat;*/ /*int fd;*/ /*char* mode = "rb+";*/ /*if (lstat(path, &lstat) == -1) {*/ /*if (errno != ENOENT) {*/ /*return NULL;*/ /*}*/ /*if ((fd = open(path, O_CREAT | O_EXCL | O_RDWR, 0600)) == -1) {*/ /*return NULL;*/ /*}*/ /*mode = "wb";*/ /*} else {*/ /*if ((fd = open(path, O_RDONLY)) == -1) {*/ /*return NULL;*/ /*}*/ /*if (fstat(fd, &fstat) == -1) {*/ /*if (lstat.st_mode != fstat.st_mode ||*/ /*lstat.st_ino != fstat.st_ino ||*/ /*lstat.st_dev != fstat.st_dev) {*/ /*close(fd);*/ /*return NULL;*/ /*}*/ /*}*/ /*ftruncate(fd, 0);*/ /*}*/ /*if ((fp = fdopen(fd, mode)) == NULL) {*/ /*close(fd);*/ /*unlink(path);*/ /*return NULL;*/ /*}*/ /*return fp;*/ } #if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) char* girara_file_read_line(FILE* file) { if (file == NULL) { return NULL; } size_t size = 0; char* line = fgetln(file, &size); if (line == NULL) { return NULL; } char* copy = g_strndup(line, size); if (copy == NULL) { return NULL; } /* remove the trailing line deliminator */ g_strdelimit(copy, "\n\r", '\0'); return copy; } #else char* girara_file_read_line(FILE* file) { if (file == NULL) { return NULL; } size_t size = 0; char* line = NULL; if (getline(&line, &size, file) == -1) { if (line != NULL) { free(line); } return NULL; } /* remove the trailing line deliminator */ g_strdelimit(line, "\n\r", '\0'); char* duplicate = g_strdup(line); free(line); return duplicate; } #endif char* girara_file_read(const char* path) { if (path == NULL) { return NULL; } FILE* file = girara_file_open(path, "r"); if (file == NULL) { return NULL; } char* content = girara_file_read2(file); fclose(file); return content; } char* girara_file_read2(FILE* file) { if (file == NULL) { return NULL; } const off_t curpos = ftello(file); if (curpos == -1) { return NULL; } fseeko(file, 0, SEEK_END); const off_t size = ftello(file) - curpos; fseeko(file, curpos, SEEK_SET); if (size == 0) { char* content = malloc(1); content[0] = '\0'; return content; } /* this can happen on 32 bit systems */ if ((uintmax_t)size >= (uintmax_t)SIZE_MAX) { girara_error("file is too large"); return NULL; } char* buffer = malloc(size + 1); if (buffer == NULL) { return NULL; } size_t read = fread(buffer, size, 1, file); if (read != 1) { free(buffer); return NULL; } buffer[size] = '\0'; return buffer; } void girara_clean_line(char* line) { if (line == NULL) { return; } unsigned int i = 0; unsigned int j = 0; bool ws_mode = true; for(i = 0; i < strlen(line); i++) { if (isspace(line[i]) != 0) { if (ws_mode == true) { continue; } line[j++] = ' '; ws_mode = true; } else { line[j++] = line[i]; ws_mode = false; } } line[j] = '\0'; } void* girara_safe_realloc(void** ptr, size_t size) { if (ptr == NULL) { return NULL; } if (size == 0) { goto error_free; } void* tmp = realloc(*ptr, size); if (tmp == NULL) { goto error_free; } *ptr = tmp; return *ptr; error_free: free(*ptr); *ptr = NULL; return NULL; } void update_state_by_keyval(int *state, int keyval) { if (state == NULL) { return; } if ((keyval >= '!' && keyval <= '/') || (keyval >= ':' && keyval <= '@') || (keyval >= '[' && keyval <= '`') || (keyval >= '{' && keyval <= '~') ) { *state |= GDK_SHIFT_MASK; } } char* girara_escape_string(const char* value) { if (value == NULL) { return NULL; } GString* str = g_string_new(""); while (*value != '\0') { const char c = *value++; if (strchr("\\ \t\"\'", c) != NULL) { g_string_append_c(str, '\\'); } g_string_append_c(str, c); } return g_string_free(str, FALSE); } char* girara_replace_substring(const char* string, const char* old, const char* new) { if (string == NULL || old == NULL || new == NULL) { return NULL; } size_t old_len = strlen(old); size_t new_len = strlen(new); /* count occurrences */ size_t count = 0; size_t i = 0; for (i = 0; string[i] != '\0'; i++) { if (strstr(&string[i], old) == &string[i]) { i += (old_len - 1); count++; } } if (count == 0) { return g_strdup(string); } char* ret = g_try_malloc0(sizeof(char) * (i - count * old_len + count * new_len + 1)); if (ret == NULL) { return NULL; } /* replace */ char* iter = ret; while (*string != '\0') { if (strstr(string, old) == string) { strncpy(iter, new, new_len); iter += new_len; string += old_len; } else { *iter++ = *string++; } } return ret; } bool girara_exec_with_argument_list(girara_session_t* session, girara_list_t* argument_list) { if (session == NULL || argument_list == NULL) { return false; } char* cmd = NULL; girara_setting_get(session, "exec-command", &cmd); if (cmd == NULL || strlen(cmd) == 0) { girara_debug("exec-command is empty, executing directly."); g_free(cmd); cmd = NULL; } bool dont_append_first_space = cmd == NULL; GString* command = g_string_new(cmd ? cmd : ""); g_free(cmd); GIRARA_LIST_FOREACH(argument_list, char*, iter, value) if (dont_append_first_space == false) { g_string_append_c(command, ' '); } dont_append_first_space = false; char* tmp = g_shell_quote(value); g_string_append(command, tmp); g_free(tmp); GIRARA_LIST_FOREACH_END(argument_list, char*, iter, value); GError* error = NULL; girara_info("executing: %s", command->str); gboolean ret = g_spawn_command_line_async(command->str, &error); if (error != NULL) { girara_warning("Failed to execute command: %s", error->message); girara_notify(session, GIRARA_ERROR, _("Failed to execute command: %s"), error->message); g_error_free(error); } g_string_free(command, TRUE); return ret; } void widget_add_class(GtkWidget* widget, const char* styleclass) { if (widget == NULL || styleclass == NULL) { return; } GtkStyleContext* context = gtk_widget_get_style_context(widget); if (gtk_style_context_has_class(context, styleclass) == FALSE) { gtk_style_context_add_class(context, styleclass); } } void widget_remove_class(GtkWidget* widget, const char* styleclass) { if (widget == NULL || styleclass == NULL) { return; } GtkStyleContext* context = gtk_widget_get_style_context(widget); if (gtk_style_context_has_class(context, styleclass) == TRUE) { gtk_style_context_remove_class(context, styleclass); } } girara-0.2.5/girara/utils.h0000644000175000017500000001253412635750323014220 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_UTILS_H #define GIRARA_UTILS_H #include #include "types.h" #include "macros.h" /** * Enum for directories specified in the XDG specification. */ typedef enum { XDG_CONFIG, /**< XDG_CONFIG_HOME */ XDG_DATA, /**< XDG_DATA_HOME */ XDG_CONFIG_DIRS, /**< XDG_CONFIG_DIRS */ XDG_DATA_DIRS, /**< XDG_DATA_DIRS */ XDG_CACHE, /**< XDG_CACHE_HOME */ } girara_xdg_path_t; /** * Returns the home directory for the given user. $HOME is prefered over the * value from g_get_home_dir. * * @param user a username or NULL to get home directory of the current user. * @return a string containing the path to the user's home directory (needs to * be freed with g_free) or NULL if the user doesn't exist. */ char* girara_get_home_directory(const char* user); /** * Returns a specific path specified in the XDG specification. ~ in paths will * not be expanded. * @param path which path to get * @return a string containing the requested patch (needs to be freed with * g_free) or NULL for invalid values. */ char* girara_get_xdg_path(girara_xdg_path_t path); /** * Opens a URI with xdg-open. * * @param uri the URI to be opened. * @return true on success, false otherwise */ bool girara_xdg_open(const char* uri); /** * Splits paths seperated by : (as in $PATH) into a list. * * @param patharray String like $PATH to split * @return a list of paths and NULL on failure. */ girara_list_t* girara_split_path_array(const char* patharray); /** * Returns a "fixed" version of path. Which means, it will be an absolute path * and fully expanded. ~ and ~user will be replaced by the current user's home * directory (user's home directory respectively). * @param path the path to "fix". * @return the "fixed" path (needs to be freed with g_free). */ char* girara_fix_path(const char* path); /** * Open a file in a safe way * * @param path Path of the file * @param mode Mode that the file should be opened * @return NULL if an error occured */ FILE* girara_file_open(const char* path, const char* mode); /** * Reads a line from the file. The returned string has to be released with * g_free. * * @param file The file stream * @return Read line or NULL if an error occured */ char* girara_file_read_line(FILE* file); /** * Reads the whole content from a file. Returned string has to be freed. * * @param path Path to the file * @return Read file or NULL if an error occured */ char* girara_file_read(const char* path); /** * Reads the whole content from a file. Returned string has to be freed. * * @param file file to read * @return Read file or NULL if an error occured */ char* girara_file_read2(FILE* file); /** * Trims and cleans a line from multiple whitespaces * * @param line */ void girara_clean_line(char* line); /** * Changes the size of the memory block by wrapping a realloc function call * In addition it frees the old memory block if realloc fails. * * @param ptr Memory space * @param size Number of bytes * @return Pointer to the allocated memory block or NULL */ void* girara_safe_realloc(void** ptr, size_t size) GIRARA_ALLOC_SIZE(2); /** * Prints a debug message. The arguments are passed to @ref _girara_debug as * last argument. */ #define girara_debug(...) _girara_debug(__func__, __LINE__, GIRARA_DEBUG, __VA_ARGS__) /** * Prints an info message. The arguments are passed to @ref _girara_debug as * last argument. */ #define girara_info(...) _girara_debug(__func__, __LINE__, GIRARA_INFO, __VA_ARGS__) /** * Prints a warning message. The arguments are passed to @ref _girara_debug as * last argument. */ #define girara_warning(...) _girara_debug(__func__, __LINE__, GIRARA_WARNING, __VA_ARGS__) /** * Prints an error message. The arguments are passed to @ref _girara_debug as * last argument. */ #define girara_error(...) _girara_debug(__func__, __LINE__, GIRARA_ERROR, __VA_ARGS__) /** * Print a message. * * @param function The calling function * @param line The line of the call * @param level The debug level of the message. * @param format printf like format string */ void _girara_debug(const char* function, int line, girara_debug_level_t level, const char* format, ...) GIRARA_PRINTF(4, 5); /** * Get the debug level. * @returns The debug level. */ girara_debug_level_t girara_get_debug_level(); /** * Set the debug level. Any message with a level lower than the debug level will * be discarded. * @param level The new debug level. */ void girara_set_debug_level(girara_debug_level_t level); /** * Escape \\, \\t, ", ' and spaces in strings. * @param value The string to be escaped. * @returns The escaped string. Needs to be freed with g_free. */ char* girara_escape_string(const char* value); /** * Replaces all occurences of \ref old in \ref string with \ref new and returns * a new allocated string * * @param string The original string * @param old String to replace * @param new Replacement string * * @return new allocated string, needs to be freed with g_free */ char* girara_replace_substring(const char* string, const char* old, const char* new); /** * Execute command from argument list * * @param session The used girara session * @param argument_list The argument list * @return true if no error occured */ bool girara_exec_with_argument_list(girara_session_t* session, girara_list_t* argument_list); #endif girara-0.2.5/girara/version.h.in0000644000175000017500000000043712513025726015146 0ustar mockmock/* See LICENSE file for license and copyright information */ #ifndef GIRARA_VERSION_H #define GIRARA_VERSION_H #define GIRARA_VERSION_MAJOR @GVMAJOR@ #define GIRARA_VERSION_MINOR @GVMINOR@ #define GIRARA_VERSION_REV @GVREV@ #define GIRARA_VERSION "@GVMAJOR@.@GVMINOR@.@GVREV@" #endif girara-0.2.5/po/Makefile0000644000175000017500000000341312635750323013514 0ustar mockmock# See LICENSE file for license and copyright information include ../config.mk include ../common.mk include ../colors.mk PROJECTNV = girara PROJECT = girara-gtk3 CATALOGS = $(sort $(wildcard *.po)) LINGUAS ?= $(patsubst %.po, %, $(CATALOGS)) ifeq ($(LINGUAS),) ALINGUAS = else ALINGUAS = $(shell find $(patsubst %, %.po, $(LINGUAS)) 2>/dev/null) endif MOS = $(patsubst %, %/LC_MESSAGES/${GETTEXT_PACKAGE}.mo, $(patsubst %.po, %, $(ALINGUAS))) all: ${MOS} clean: $(QUIET)rm -rf POTFILES.in POTFILES.in.tmp $(patsubst %.po, %, $(CATALOGS)) ${PROJECT}.pot POTFILES.in: $(sort $(wildcard ../girara/*.c)) $(QUIET) set -e && rm -f $@.tmp && touch $@.tmp && \ for f in $(^F) ; do \ echo girara/$$f >> $@.tmp ; \ done && \ mv $@.tmp $@ ${GETTEXT_PACKAGE}.pot: POTFILES.in $(ECHO) regenerate $@ $(QUIET)intltool-update --pot --gettext-package=${GETTEXT_PACKAGE} update-po: ${GETTEXT_PACKAGE}.pot $(call colorecho,PO,"Updating po files ${CATALOGS}") $(QUIET)set -e && for f in ${CATALOGS} ; do \ intltool-update --dist --gettext-package=${GETTEXT_PACKAGE} `echo $$f | sed 's/\.po//'` ; \ sed -i 's/Report-Msgid-Bugs-To: \\n/Report-Msgid-Bugs-To: http:\/\/bugs.pwmt.org\\n/' "$$f" ; \ done %/LC_MESSAGES/${GETTEXT_PACKAGE}.mo: %.po @mkdir -p $(@D) $(call colorecho,MSGFMT,$(shell echo $< | sed 's/\.po//')) $(QUIET)${MSGFMT} ${MSGFMTFLAGS} -c $< -o $@ install: ${MOS} $(call colorecho,INSTALL,"Install translations") $(QUIET)set -e && for f in $^ ; do \ mkdir -p -m 755 $(DESTDIR)$(LOCALEDIR)/`dirname $$f`; \ install -m 644 $$f $(DESTDIR)$(LOCALEDIR)/`dirname $$f` ; \ done uninstall: ${MOS} $(call colorecho,UNINSTALL,"Uninstall translations") $(QUIET)set -e && for f in $^ ; do \ rm -f $(LOCALEDIR)/$$f; \ done .PHONY: all clean install uninstall update-po girara-0.2.5/po/de.po0000644000175000017500000001654212635750323013013 0ustar mockmock# girara - language file (German) # See LICENSE file for license and copyright information # # Translators: # , 2012 # Mario Blättermann , 2012 # Moritz Lipp , 2012 # rike, 2014 msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:49+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: German (http://www.transifex.com/projects/p/girara/language/" "de/)\n" "Language: de\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Ungültige zugewiesene Funktion: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Ungültige Anzahl an Argumente übergeben: %zu anstatt von mindestens %u" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Modus ist nicht registriert: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Ungültiger Modifikator in %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Ungültige Sondertaste für %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Ungültige Sondertaste oder Modus %s" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Ungültige zugewiesene Funktion: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Zu wenige Argumente." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Zu viele Argumente." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Unbekannte Otion: %s" #: ../girara/commands.c:452 msgid "true" msgstr "wahr" #: ../girara/commands.c:452 msgid "false" msgstr "falsch" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Kein Wert für Option definiert: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Unbekannter Wert für Option: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Schriftart" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Standardfarbe des Vordergrunds" #: ../girara/config.c:204 msgid "Default background color" msgstr "Standardfarbe des Hintergrunds" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Vordergrundfarbe der Eingabezeile" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Hintergrundfarbe der Eingabezeile" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Vordergrundfarbe der Statuszeile" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Hintergrundfarbe der Statuszeile" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Vordergrundfarbe der Vervollständigung" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Hintergrundfarbe der Vervollständigung" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Vordergrundfarbe der Vervollständigung (Gruppe)" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Hintergrundfarbe der Vervollständigung (Gruppe)" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Vordergrundfarbe der Vervollständigung (Hervorhebung)" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Hintergrundfarbe der Vervollständigung (Hervorhebung)" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Vordergrundfarbe der Benachrichtigung (Fehler)" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Hintergrundfarbe der Benachrichtigung (Fehler)" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Vordergrundfarbe der Benachrichtigung (Warnung)" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Hintergrundfarbe der Benachrichtigung (Warnung)" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Vordergrundfarbe der Benachrichtigung" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Hintergrundfarbe der Benachrichtigung" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "Vordergrundfarbe der Bildlaufleiste" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "Hintergrundfarbe der Bildlaufleiste" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Registerleisten Vordergrundfarbe" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Registerleisten Hintergrundfarbe" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Registerleisten Vordergrundfarbe (aktiv)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Registerleisten Hintergrundfarbe (aktiv)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Ausgangsbreite des Fensters" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Ausgangshöhe des Fensters" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" "Horizontaler innerer Rand für das Statusfeld und die Benachrichtigungsleiste" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" "Vertikaler innerer Rand für das Statusfeld und die Benachrichtigungsleiste" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Anzahl der Elemente in der Vervollständigung" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "Zeige horizontale und vertikale Bildlaufleiste" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "Zeige horizontale Bildlaufleiste" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "Zeige vertikale Bildlaufleiste" #: ../girara/config.c:236 msgid "Window icon" msgstr "Fenstericon" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Befehl, der von :exec ausgeführt werden soll" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Zeige oder verstecke bestimmte GUI Elemente" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "Aktiviere glattes Bildschirmrollen und Vergrößern" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Führe einen Befehl aus." #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Tastenfolge zuweisen" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Beende das Programm" #: ../girara/config.c:281 msgid "Set an option" msgstr "Setze eine Option" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Tastenfolge entbinden" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "Speichere Einstellungen in einer Datei" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "Ungültige Anzahl an Argumente übergeben: %zu anstatt von 1" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Konnte Befehl nicht ausführen: %s" girara-0.2.5/po/el.po0000644000175000017500000001752712635750323013027 0ustar mockmock# girara - language file (Greek) # See LICENSE file for license and copyright information # # Translators: # Nisok Kosin , 2012. # Nisok Kosin , 2012. msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:35+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: Greek (http://www.transifex.com/projects/p/girara/language/" "el/)\n" "Language: el\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Μη έγγυρη εντολή: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Εισαγωγή μη έγγυρου αριθμού παραμέτρων: %zu αντί κατ'ελάχιστο %u" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Επιλέχθηκε μη καταχωρημένη λειτουργία: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Μη έγγυρος τροποποιητής στο %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Μη έγγυρη επιλογή ειδικού πλήκτρου στο %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Μη έγγυρη τιμή ειδικού πλήκτρου %s" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Μη έγγυρη συντόμευση λειτουργίας: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Ανεπαρκείς παράμετροι" #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Πολλές παράμετροι" #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Μή έγγυρη επιλογή: %s" #: ../girara/commands.c:452 msgid "true" msgstr "Αληθές" #: ../girara/commands.c:452 msgid "false" msgstr "Ψευδές" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Καμία τιμή δεν έχει καθοριστεί για την επιλογή: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Άγνωστη τιμή για την επιλογή: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Γραμματοσειρά" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Προεπιλεγμένο χρώμα προσκηνίου" #: ../girara/config.c:204 msgid "Default background color" msgstr "Προεπιλεγμένο χρώμα πρασκηνίου" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Χρώμα μπάρας εισαγωγής" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Χρώμα φόντου μπάρας εισαγωγής" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Χρώμα μπάρας κατάστασης" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Χρώμα φόντου μπάρας κατάστασης" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Χρώμα επιλογών συμπλήρωσης" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Χρώμα συμπλήρωσης λέξεων" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Χρώμα μενού συμπλήρωσης λέξεων" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Χρώμα φόντου του μενού συμπλήρωσης λέξεων" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Χρώμα τονισμού συμπλήρωσης λέξεων" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Χρώμα φόντου τονισμού συμπλήρωσης λέξεων" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Χρώμα ειδοποίησης σφάλματος" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Χρώμα φόντου ειδοποίησης σφάλματος" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Χρώμα ειδοποίησης προειδοποίησης" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Χρώμα φόντου ειδοποίησης προειδοποίησης" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Χρώμα ειδοποίησης" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Χρώμα φόντου ειδοποίησης" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Χρώμα μπάρας καρτελών" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Χρώμα φόντου μπάρας καρτελών" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Χρώμα μπάρας καρτελών (ενεργό)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Χρώμα φόντου μπάρας καρτελών (ενεργό)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Αρχικό πλάτος παραθύρου" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Αρχικό ύψος παραθύρου" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Αριθμός στοιχείων συμπλήρωσης" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "" #: ../girara/config.c:236 msgid "Window icon" msgstr "Εικονίδιο παραθύρου" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Η εντολή που θα εκτελεστεί στο :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Εμφάνιση είτε απόκριψη συγκεκριμένω στοιχείων του GUI" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Εκτέλεση εντολής" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Χαρτογράφηση / map αλληλουχίας πλήκτρων" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Εγκατάληψη της εφαρμογής" #: ../girara/config.c:281 msgid "Set an option" msgstr "Ρύθμιση επιλογής" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Απόχαρτογράφηση / unmap αλληλουχίας πλήκτρων" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Αποτυχία στην εκτέλεση της εντολής: %s" girara-0.2.5/po/eo.po0000644000175000017500000001451212635750323013021 0ustar mockmock# girara - language file (Esperanto) # See LICENSE file for license and copyright information # # Translators: msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:35+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: LANGUAGE \n" "Language: eo\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Nevalida kurtnomo de funkcio: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Nevalida nombro da argumentoj transdonita: %zu anstataŭ de almenaŭ %u" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Neregistrita modo specifita: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Nevalida modifilo en %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Nevalida speciala klavvaloro por %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Nevalida speciala klavvaloro aŭ reĝimo %s" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Nevalida kurtnomo de funkcio: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Ne sufiĉe da argumentoj." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Tro multe da argumentoj." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Nekonata opcio: %s" #: ../girara/commands.c:452 msgid "true" msgstr "vero" #: ../girara/commands.c:452 msgid "false" msgstr "falso" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Neniu valoro difinita por opcio: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Nekonata valoro por opcio: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Tiparo" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Defaŭlta malfona koloro" #: ../girara/config.c:204 msgid "Default background color" msgstr "Defaŭlta fona koloro" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Malfona koloro de enigbreto" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Fona koloro de enigbreto" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Malfona koloro de statbreto" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Fona koloro de statbreto" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Malfona koloro de kompletigo" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Fona koloro de kompletigo" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Malfona koloro de kompletiga grupo" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Fona koloro de kompletiga grupo" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Malfonluma koloro de kompletigo" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Fonluma koloro de kompletigo" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Malfona koloro de erarsciigo" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Fona koloro de erarsciigo" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Malfona koloro de avertsciigo" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Fona koloro de avertsciigo" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Malfona koloro de sciigo" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Fona koloro de sciigo" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Malfona koloro de slipbreto" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Fona koloro de slipbreto" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Malfona koloro de slipbreto (aktiva)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Fona koloro de slipbreto (aktiva)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Larĝeco de inita fenestro" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Alteco de inita fenestro" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Nombro da kompletigeroj" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "" #: ../girara/config.c:236 msgid "Window icon" msgstr "Fenestra piktogramo" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Komando por plenumi en :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Plenumi komandon" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Mapu klavan sinsekvon" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Eliru el programo" #: ../girara/config.c:281 msgid "Set an option" msgstr "Agordu opcion" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Malmapu klavan sinsekvon" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Fiaskis plenumi komandon: %s" girara-0.2.5/po/es.po0000644000175000017500000001540612635750323013030 0ustar mockmock# girara - language file (Spanish) # See LICENSE file for license and copyright information # # Translators: # joserc87 , 2014 # Moritz Lipp , 2012 msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:35+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: Spanish (http://www.transifex.com/projects/p/girara/language/" "es/)\n" "Language: es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Función 'atajo' no valida: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Número de argumentos invalido: %zu, cuando se necesitan al menos %u" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Modo no registrado especificado: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Modificador inválido en %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Valor de tecla especial inválido para %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Valor o modo de tecla especial inválido para %s" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Función 'atajo' no valida: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Número de argumentos insuficiente." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Demasiados argumentos." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Opción desconocida: %s" #: ../girara/commands.c:452 msgid "true" msgstr "cierto" #: ../girara/commands.c:452 msgid "false" msgstr "falso" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Valor indefinido para la opción: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Valor desconocido para la opción: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Fuente" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Color por omisión" #: ../girara/config.c:204 msgid "Default background color" msgstr "Color de fondo por omisión" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Color de la barra de entrada" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Color de fondo de la barra de entrada" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Color de la barra de estado" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Color de fondo de la barra de estado" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Color de completado" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Color de fondo de completado" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Color de los grupos de completado" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Color de fondo de los grupos de completado" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Color de la entrada de completado destacada" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Color de fondo de la entrada de completado destacada" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Color de las notificaciones de error" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Color de fondo de las notificaciones de error" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Color de las advertencias" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Color de fondo de las advertencias" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Color de las notificaciones" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Color de fondo de las notificaciones" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Color de la barra 'tabulador'" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Color de fondo de la barra 'tabulador'" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Color de la barra 'tabulador' (activa)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Color de fondo de la barra 'tabulador' (activa)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Anchura inicial de la ventana" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Altura inicial de la ventana" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Número de elementos en el completado" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "" #: ../girara/config.c:236 msgid "Window icon" msgstr "Icono de la ventana" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Comando a ejecutar en :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Mostrar u ocultar determinados elementos de la interfaz de usuario" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Ejecutar un comando" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Mapear una secuéncia de teclas" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Salir del programa" #: ../girara/config.c:281 msgid "Set an option" msgstr "Asignar un valor a una opción" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Quitar el mapeo de una secuencia de teclas" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "No se pudo ejecutar el comando: %s" girara-0.2.5/po/fr.po0000644000175000017500000001611112635750323013022 0ustar mockmock# girara - language file (French) # See LICENSE file for license and copyright information # # Translators: # Richard Gill , 2012. # Benoît Knecht , 2013. # rike, 2013 msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:35+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: French (http://www.transifex.com/projects/p/girara/language/" "fr/)\n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n > 1);\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Pas une commande valide : %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Nombre d'arguments invalide : %zu à la place d'au moins %u" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Mode non enregistré spécifié : %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Modificateur invalide dans %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Valeur de touche spéciale invalide pour %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Valeur de touche spéciale ou mode %s invalide" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Pas une fonction raccourci valide : %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Pas assez d'arguments." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Trop d'arguments." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Option inconnue : %s" #: ../girara/commands.c:452 msgid "true" msgstr "vrai" #: ../girara/commands.c:452 msgid "false" msgstr "faux" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Aucune valeur définie pour l'option : %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Valeur inconnue pour l'option : %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Police" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Couleur par défaut du texte" #: ../girara/config.c:204 msgid "Default background color" msgstr "Couleur par défaut du fond" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Couleur du texte de la barre de saisie" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Couleur de fond de la barre de saisie" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Couleur du texte de la barre d'état" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Couleur de fond de la barre d'état" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Couleur du texte de la complétion" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Couleur de fond de la complétion" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Couleur du texte du groupe de complétion" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Couleur de fond du groupe de complétion" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Couleur du texte du surlignage de complétion" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Couleur de fond du surlignage de complétion" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Couleur du texte des notifications d'erreur" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Couleur de fond des notifications d'erreur" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Couleur du texte des notifications d'avertissement" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Couleur de fond des notifications d'avertissement" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Couleur du texte des notifications" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Couleur de fond des notifications" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Couleur du texte des onglets" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Couleur de fond des onglets" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Couleur du texte de l'onglet actif" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Couleur de fond de l'onglet actif" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Largeur initiale de la fenêtre" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Hauteur initiale de la fenêtre" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" "Espacement horizontal pour le champ de statut et les barres de notification" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" "Espacement vertical pour le champ de statut et les barres de notification" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Nombre d'éléments de complétion" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "Afficher les ascenseur vertical et horizontal" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "Afficher l'ascenseur horizontal" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "Afficher l'ascenseur vertical" #: ../girara/config.c:236 msgid "Window icon" msgstr "Icône de fenêtre" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Commande à exécuter dans :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Afficher ou cacher certains éléments de l'interface" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Exécuter une commande" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Associer une séquence de touches" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Quitter le programme" #: ../girara/config.c:281 msgid "Set an option" msgstr "Placer une option" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Désassocier une séquence de touches" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Échec d'exécution de la commande : %s" girara-0.2.5/po/he.po0000644000175000017500000001226312635750323013013 0ustar mockmock# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # # Translators: msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2013-11-20 09:46+0000\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: Hebrew (http://www.transifex.com/projects/p/girara/language/" "he/)\n" "Language: he\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "" #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "" #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "" #: ../girara/commands.c:452 msgid "true" msgstr "" #: ../girara/commands.c:452 msgid "false" msgstr "" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "" #: ../girara/config.c:204 msgid "Default background color" msgstr "" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "" #: ../girara/config.c:210 msgid "Completion background color" msgstr "" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "" #: ../girara/config.c:220 msgid "Notification background color" msgstr "" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "" #: ../girara/config.c:228 msgid "Initial window width" msgstr "" #: ../girara/config.c:229 msgid "Initial window height" msgstr "" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "" #: ../girara/config.c:236 msgid "Window icon" msgstr "" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "" #: ../girara/config.c:280 msgid "Quit the program" msgstr "" #: ../girara/config.c:281 msgid "Set an option" msgstr "" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "" girara-0.2.5/po/it.po0000644000175000017500000001572012635750323013034 0ustar mockmock# girara - language file (Italian) # See LICENSE file for license and copyright information # # Translators: # TheLemonMan , 2012,2015 msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:35+0100\n" "Last-Translator: TheLemonMan \n" "Language-Team: Italian (http://www.transifex.com/projects/p/girara/language/" "it/)\n" "Language: it\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Comando non valido: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Numero degli argomenti non valido: %zu immessi, %u attesi" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Modalità non registrata: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Modificatore invalido in %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Valore della chiave speciale %s non valido " #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Valore della chiave speciale o modalità %s non valida" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Scorciatoia invalida: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Non abbastanza argomenti specificati." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Troppi argomenti specificati." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Opzione sconosciuta: %s" #: ../girara/commands.c:452 msgid "true" msgstr "vero" #: ../girara/commands.c:452 msgid "false" msgstr "falso" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Nessun valore definito per l' opzione: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Valore sconosciuto per l' opzione: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Font" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Colore del testo di default" #: ../girara/config.c:204 msgid "Default background color" msgstr "Colore di sfondo di default" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Colore del testo della barra dei comandi" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Colore di sfondo della barra dei comandi" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Colore del testo della barra di stato" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Colore di sfondo della barra di stato" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Colore del testo del completamento" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Colore di sfondo del completamento" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Colore del testo del gruppo di completamento" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Colore di sfondo del gruppo di completamento" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Colore del testo del completamento evidenziato" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Colore di sfondo del completamento evidenziato" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Colore del testo della notifica di errore" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Colore di sfondo della notifica di errore" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Colore del testo della notifica d' avvertimento" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Colore di sfondo della notifica d' avvertimento" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Colore del testo della notifica" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Colore di sfondo della notifica" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Colore del testo del tab" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Colore di sfondo del tab" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Colore del testo del tab (attivo)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Colore di sfondo del tab (attivo)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Larghezza iniziale della finestra" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Altezza iniziale della finestra" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "Bordo orizzontale per le barre di input e notifica" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "Bordo verticale per le barre di input e notifica" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Numero di possibili completamenti" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "Mostra entrambe le scrollbar" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "Mostra la scrollbar orizzontale" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "Mostra la scrollbar verticale" #: ../girara/config.c:236 msgid "Window icon" msgstr "Icona della finestra" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Comando da eseguire in :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Mostra o nascondi gli elementi della GUI" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Esegui un comando" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Mappa una sequenza di tasti" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Esci dal programma" #: ../girara/config.c:281 msgid "Set an option" msgstr "Imposta un opzione" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Cancella mappatura di una sequenza di tasti" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "Numero degli argomenti non valido: %zu immessi, 1 attesi" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Impossibile eseguire il comando: %s" girara-0.2.5/po/pl.po0000644000175000017500000001510412635750323013027 0ustar mockmock# girara - language file (Polish) # See LICENSE file for license and copyright information # # Translators: # p , 2012. msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:35+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: Polish (http://www.transifex.net/projects/p/girara/language/" "pl/)\n" "Language: pl\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 " "|| n%100>=20) ? 1 : 2);\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Nieprawidłowa funkcja skrótu: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Nieprawidłowa liczba parametrów polecenia: %zu zamiast co najmniej %u" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Wybrano nieistniejący tryb: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Nieprawidłowy klawisz modyfikujący: %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Nieprawidłowa wartość klawisza: %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Nieprawidłowa wartość klawisza lub trybu: %s" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Nieprawidłowa funkcja skrótu: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Za mało parametrów polecenia" #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Za dużo parametrów polecenia" #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Nieznana opcja: %s" #: ../girara/commands.c:452 msgid "true" msgstr "prawda" #: ../girara/commands.c:452 msgid "false" msgstr "fałsz" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Niezdefiniowana wartość opcji: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Nieznana wartość opcji: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Font" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Domyślny kolor pierwszoplanowy" #: ../girara/config.c:204 msgid "Default background color" msgstr "Domyślny kolor tła" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Kolor tekstu w polu wprowadzania" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Kolor tła pola wprowadzania" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Kolor tekstu w pasku stanu" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Kolor tła paska stanu" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Kolor tekstu wyróżnienia" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Kolor tła wyróżnienia" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Kolor tekstu wyróżnionej grupy " #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Kolor tła wyróżnionej grupy" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Kolor tekstu bieżącego wyróżnienia" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Kolor tła bieżącego wyróżnienia" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Kolor tekstu powiadomienia o błędzie" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Kolor tła powiadomienia o błędzie" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Kolor tekstu ostrzeżenia" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Kolor tła ostrzeżenia" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Kolor tekstu powiadomienia" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Kolor tła powiadomienia" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Kolor tekstu paska kart" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Kolor tła paska kart" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Kolor tekstu bieżącej karty" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Kolor tła bieżącej karty" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Początkowa szerokość okna" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Początkowa wysokość okna" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Liczba wyróżnień" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "" #: ../girara/config.c:236 msgid "Window icon" msgstr "Ikona okna" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Polecenie uruchomienia w :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Pokaż/ukryj niektóre elementy interfejsu." #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Wykonaj polecenie" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Dowiąż sekwencję klawiszy" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Zakończ program" #: ../girara/config.c:281 msgid "Set an option" msgstr "Ustaw opcję" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Usuń sekwencję klawiszy" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Nieudane uruchomienie polecenia: %s" girara-0.2.5/po/pt_BR.po0000644000175000017500000001533212635750323013425 0ustar mockmock# girara - language file (Portuguese (Brazil)) # See LICENSE file for license and copyright information # # Translators: # salmora8 , 2012-2013 msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:36+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: Portuguese (Brazil) (http://www.transifex.com/projects/p/" "girara/language/pt_BR/)\n" "Language: pt_BR\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n > 1);\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Nenhum comando válido: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Número de argumentos passados inválidos: %zu em vez de %u no minimo" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Modo não registrado especificado: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Modificador inválido em %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Valor de tecla especial inválido para %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Valor de tecla especial inválido ou modo %s" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Não é uma função de atalho válida: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Argumento não suficientes." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Muitos argumentos." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Opção desconhecida: %s" #: ../girara/commands.c:452 msgid "true" msgstr "verdadeiro" #: ../girara/commands.c:452 msgid "false" msgstr "falso" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Não há valor definido para a opção: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Valor desconhecido para opção: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Fonte" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Cor de primeiro plano padrão" #: ../girara/config.c:204 msgid "Default background color" msgstr "Cor de fundo padrão" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Cor da barra de entrada" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Cor de fundo da barra de entrada" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Cor da barra de status" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Cor de fundo da barra de status" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Acabamento de cor" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Cor de fundo de acabamento" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Cor dos grupos de acabamento" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Cor de fundo dos grupos de acabamento" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Acabamento de entrada destacada" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Acabamento cor de fundo destacada" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Cor das notificações de erro" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Cor de fundo das notificações de erro" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Cor dos avisos" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Cor de fundo dos avisos" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Cor das notificações" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Cor de fundo das notificação" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Cor da barra de abas" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Cor de fundo da barra de abas" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Cor da barra de abas (ativo)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Cor de fundo da barra de abas (ativo)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Largura de janela inicial" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Altura de janela inicial" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" "Preenchimento vertical para a entrada de status e barras de notificações" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Número de itens de acabamento" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "Mostrar as barras horizontal e vertical" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "Mostrar barra horizontal" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "Mostrar barra vertical" #: ../girara/config.c:236 msgid "Window icon" msgstr "Ícone de janela" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Comando para executar em :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Mostrar ou ocultar certos elementos da GUI" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Executar um comando" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Mapear uma sequencia de teclas" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Sair do programa" #: ../girara/config.c:281 msgid "Set an option" msgstr "Definir uma opção" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Desmapear uma sequencia de teclas" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Falha ao executar comando: %s" girara-0.2.5/po/ru.po0000644000175000017500000002120412635750323013040 0ustar mockmock# girara - language file (Russian) # See LICENSE file for license and copyright information # # Translators: # Vladimir Lomov , 2013,2015 msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:36+0100\n" "Last-Translator: Vladimir Lomov \n" "Language-Team: Russian (http://www.transifex.com/mlq/girara/language/ru/)\n" "Language: ru\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n" "%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || (n" "%100>=11 && n%100<=14)? 2 : 3);\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Неправильная команда: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "Передано неверное количество аргументов: %zu вместо как минимум %u" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Указан незарегистрированный режим: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "Неправильный модификатор в %s" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "Неправильное значение для специальной клавиши %s" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "Неправильное значения для специальной клавиши или режим %s" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Неправильная функция комбинации: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Недостаточно аргументов." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Слишком много аргументов." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Неизвестный параметр: %s" #: ../girara/commands.c:452 msgid "true" msgstr "правда" #: ../girara/commands.c:452 msgid "false" msgstr "ложь" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Для параметра: %s не задано значение" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Неизвестное значение для параметра: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Шрифт" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Цвет текста по умолчанию" #: ../girara/config.c:204 msgid "Default background color" msgstr "Цвет фона по умолчанию" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Цвет текста в поле ввода" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Цвет фона в поле ввода" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Цвет текста статусной строки" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Цвет фона статусной строки" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Цвет текста для автодополнения" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Цвет фона для автодополнения" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Цвет текста группы автодополнения" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Цвет фона группы автодополнения" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Цвет текста выделения в автодополнении" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Цвет фона выделения в автодополнении" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Цвет текста в уведомлениях об ошибке" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Цвет фона в уведомлениях об ошибке" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Цвет текста в предупреждающих уведомлениях" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Цвет фона в предупреждающих уведомлениях" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Цвет текста в уведомлениях" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Цвет фона в уведомлениях" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Цвет текста в строке вкладок" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Цвет фона в строке вкладок" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Цвет текста в строке вкладок (активная)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Цвет фона строки вкладок (активная)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Начальная ширина окна" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Начальная высота окна" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "Горизонтальные промежутки для статусной строки и строки уведомлений" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "Вертикальный промежуток для статусной строки и области уведомления" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Количество элементов в автодополнении" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "Показать горизонтальную и вертикальную прокрутки" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "Показать горизонтальную прокрутку" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "Показать вертикальную прокрутку" #: ../girara/config.c:236 msgid "Window icon" msgstr "Значок окна" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr "Команда для выполнения через :exec" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Показать или скрыть определённые элементы графического интерфейса" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "Включить плавную прокрутку и увеличение" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Выполнить команду" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Задать клавиатурную комбинацию" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Завершить программу" #: ../girara/config.c:281 msgid "Set an option" msgstr "Задать параметр" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Убрать определение с клавиатурной комбинации" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "Передано неверное количество аргументов: %zu вместо как минимум 1" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Не удалось выполнить команду: %s" girara-0.2.5/po/tr.po0000644000175000017500000001535412635750323013050 0ustar mockmock# girara - language file (Turkish) # See LICENSE file for license and copyright information # # Translators: # hsngrms , 2012 # femnad , 2012 msgid "" msgstr "" "Project-Id-Version: girara\n" "Report-Msgid-Bugs-To: http://bugs.pwmt.org\n" "POT-Creation-Date: 2015-12-14 22:01+0100\n" "PO-Revision-Date: 2015-12-14 21:36+0100\n" "Last-Translator: Sebastian Ramacher \n" "Language-Team: Turkish (http://www.transifex.net/projects/p/girara/language/" "tr/)\n" "Language: tr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" "X-Generator: Poedit 1.6.10\n" #. unhandled command #: ../girara/callbacks.c:501 #, c-format msgid "Not a valid command: %s" msgstr "Geçerli bir kısayol fonksiyonu değil: %s" #: ../girara/commands.c:110 ../girara/commands.c:310 #, c-format msgid "Invalid number of arguments passed: %zu instead of at least %u" msgstr "" "Yanlış sayıda argüman geçildi: %zu adet argüman geçildi, oysa en az %u adet " "argüman olması gerekiyor" #: ../girara/commands.c:144 #, c-format msgid "Unregistered mode specified: %s" msgstr "Kayıtlı olmayan mod belirtildi: %s" #: ../girara/commands.c:176 #, c-format msgid "Invalid modifier in %s" msgstr "%s içinde geçersiz dönüştürücü" #: ../girara/commands.c:215 #, c-format msgid "Invalid special key value for %s" msgstr "%s için geçersiz özel tuş" #: ../girara/commands.c:251 #, c-format msgid "Invalid special key value or mode %s" msgstr "%s için geçersiz tuş özel veya mod" #: ../girara/commands.c:332 #, c-format msgid "Not a valid shortcut function: %s" msgstr "Geçerli bir kısayol fonksiyonu değil: %s" #: ../girara/commands.c:420 msgid "Not enough arguments." msgstr "Yeterince argüman geçilmedi." #: ../girara/commands.c:425 msgid "Too many arguments." msgstr "Gereğinden fazla argüman." #: ../girara/commands.c:438 #, c-format msgid "Unknown option: %s" msgstr "Bilinmeyen seçenek: %s" #: ../girara/commands.c:452 msgid "true" msgstr "doğru" #: ../girara/commands.c:452 msgid "false" msgstr "yanlış" #: ../girara/commands.c:484 #, c-format msgid "No value defined for option: %s" msgstr "Seçenek için değer belirtilmedi: %s" #: ../girara/commands.c:499 #, c-format msgid "Unknown value for option: %s" msgstr "Seçenek için bilinmeyen değer: %s" #. settings #: ../girara/config.c:202 msgid "Font" msgstr "Yazı tipi" #: ../girara/config.c:203 msgid "Default foreground color" msgstr "Varsayılan yazı tipi rengi" #: ../girara/config.c:204 msgid "Default background color" msgstr "Varsayılan arka plan rengi" #: ../girara/config.c:205 msgid "Inputbar foreground color" msgstr "Giriş çubuğu yazı tipi rengi" #: ../girara/config.c:206 msgid "Inputbar background color" msgstr "Giriş çubuğu arka plan rengi" #: ../girara/config.c:207 msgid "Statusbar foreground color" msgstr "Durum çubuğu yazı tipi rengi" #: ../girara/config.c:208 msgid "Statsubar background color" msgstr "Durum çubuğu arka plan rengi" #: ../girara/config.c:209 msgid "Completion foreground color" msgstr "Tamamlama yazı tipi rengi" #: ../girara/config.c:210 msgid "Completion background color" msgstr "Tamamlama arka plan rengi" #: ../girara/config.c:211 msgid "Completion group foreground color" msgstr "Tamamlama grubu yazı tipi rengi" #: ../girara/config.c:212 msgid "Completion group background color" msgstr "Tamamlama grubu arka plan rengi" #: ../girara/config.c:213 msgid "Completion highlight foreground color" msgstr "Tamamlama vurgulama yazı tipi rengi" #: ../girara/config.c:214 msgid "Completion highlight background color" msgstr "Tamamlama vurgulama arka plan rengi" #: ../girara/config.c:215 msgid "Error notification foreground color" msgstr "Hata bildirimi yazı tipi rengi" #: ../girara/config.c:216 msgid "Error notification background color" msgstr "Hata bildirimi arka plan rengi" #: ../girara/config.c:217 msgid "Warning notification foreground color" msgstr "Uyarı bildirimi yazı tipi rengi" #: ../girara/config.c:218 msgid "Warning notifaction background color" msgstr "Uyarı bildirimi arka plan rengi" #: ../girara/config.c:219 msgid "Notification foreground color" msgstr "Bildirim yazı tipi rengi" #: ../girara/config.c:220 msgid "Notification background color" msgstr "Bildirim arka plan rengi" #: ../girara/config.c:221 msgid "Scrollbar foreground color" msgstr "" #: ../girara/config.c:222 msgid "Scrollbar background color" msgstr "" #: ../girara/config.c:223 msgid "Tab bar foreground color" msgstr "Sekme çubuğu yazı tipi rengi" #: ../girara/config.c:224 msgid "Tab bar background color" msgstr "Sekme çubuğu arka plan rengi" #: ../girara/config.c:225 msgid "Tab bar foreground color (active)" msgstr "Seçme çubuğu yazı tipi rengi (etkin)" #: ../girara/config.c:226 msgid "Tab bar background color (active)" msgstr "Sekme çubuğu arka plan rengi (etkin)" #: ../girara/config.c:228 msgid "Initial window width" msgstr "Başlangıçtaki pencere genişliği" #: ../girara/config.c:229 msgid "Initial window height" msgstr "Başlangıçtaki pencere yüksekliği" #: ../girara/config.c:230 msgid "Horizontal padding for the status input and notification bars" msgstr "" #: ../girara/config.c:231 msgid "Vertical padding for the status input and notification bars" msgstr "" #: ../girara/config.c:232 msgid "Number of completion items" msgstr "Tamamlama öğelerinin sayısı" #: ../girara/config.c:233 msgid "Show both the horizontal and vertical scrollbars" msgstr "" #: ../girara/config.c:234 msgid "Show the horizontal scrollbar" msgstr "" #: ../girara/config.c:235 msgid "Show the vertical scrollbar" msgstr "" #: ../girara/config.c:236 msgid "Window icon" msgstr "Pencere ikonu" #: ../girara/config.c:237 msgid "Command to execute in :exec" msgstr ":exec için yürütülecek komut" #: ../girara/config.c:238 msgid "Show or hide certain GUI elements" msgstr "Belirlenmiş GUI bileşenlerini göster ya da gizle" #: ../girara/config.c:239 msgid "Enable smooth scrolling and zooming" msgstr "" #. commands #: ../girara/config.c:278 msgid "Execute a command" msgstr "Komut yürüt" #: ../girara/config.c:279 msgid "Map a key sequence" msgstr "Tuş kombinasyonu eşleştir" #: ../girara/config.c:280 msgid "Quit the program" msgstr "Programdan çık" #: ../girara/config.c:281 msgid "Set an option" msgstr "Seçenekleri değiştir" #: ../girara/config.c:282 msgid "Unmap a key sequence" msgstr "Tuş kombinasyonu eşleşimini kaldır" #: ../girara/config.c:284 msgid "Dump settings to a file" msgstr "" #: ../girara/settings.c:244 #, c-format msgid "Invalid number of arguments passed: %zu instead of 1" msgstr "" #: ../girara/utils.c:524 #, c-format msgid "Failed to execute command: %s" msgstr "Komut yürütülemedi: %s" girara-0.2.5/tests/Makefile0000644000175000017500000000675312513025726014247 0ustar mockmock# See LICENSE file for license and copyright information include ../config.mk include ../common.mk include ../colors.mk include config.mk PROJECT = test SOURCE = tests.c $(wildcard test_*.c) OBJECTS = $(addprefix ${BUILDDIR_RELEASE}/,${SOURCE:.c=.o}) OBJECTS_DEBUG = $(addprefix ${BUILDDIR_DEBUG}/,${SOURCE:.c=.o}) OBJECTS_GCOV = $(addprefix ${BUILDDIR_GCOV}/,${SOURCE:.c=.o}) GIRARA_OBJECTS = $(wildcard ${GIRARA_RELEASE}/*.o) GIRARA_OBJECTS_DEBUG = $(wildcard ${GIRARA_DEBUG}/*.o) GIRARA_OBJECTS_GCOV = $(wildcard ${GIRARA_GCOV}/*.o) XDG_HELPER_SOURCE = xdg_test_helper.c XDG_HELPER = $(addprefix ${BUILDDIR_RELEASE}/,${XDG_HELPER_SOURCE:.c=}) CPPFLAGS += -I../girara -DXDG_TEST_HELPER=\"${XDG_HELPER}\" all: release ${XDG_HELPER} ../girara/version.h: $(MAKE) -C .. girara/version.h # release ${OBJECTS}: config.mk ../config.mk ../girara/version.h ${BUILDDIR_RELEASE}/%.o: %.c $(call colorecho,CC,$<) @mkdir -p ${DEPENDDIR}/$(dir $(abspath $@)) @mkdir -p $(dir $(abspath $@)) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} \ -o $@ $< -MMD -MF ${DEPENDDIR}/$(abspath $@).dep ${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT}: ${OBJECTS} $(QUIET)$(MAKE) -C .. release $(call colorecho,CC,$@) @mkdir -p ${BUILDDIR_RELEASE}/${BINDIR} $(QUIET)${CC} ${SFLAGS} ${LDFLAGS} \ -o ${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT} \ ${OBJECTS} ${GIRARA_OBJECTS} ${LIBS} release: ${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT} run: release ${XDG_HELPER} $(QUIET)./${BUILDDIR_RELEASE}/${BINDIR}/${PROJECT} # debug ${OBJECTS_DEBUG}: config.mk ../config.mk ../girara/version.h ${BUILDDIR_DEBUG}/%.o: %.c @mkdir -p ${DEPENDDIR}/$(dir $(abspath $@)) @mkdir -p $(dir $(abspath $@)) $(call colorecho,CC,$<) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} ${DFLAGS} \ -o $@ $< -MMD -MF ${DEPENDDIR}/$(abspath $@).dep ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT}: ${OBJECTS_DEBUG} $(QUIET)$(MAKE) -C .. debug $(call colorecho,CC,$@) @mkdir -p ${BUILDDIR_DEBUG}/${BINDIR} $(QUIET)${CC} ${SFLAGS} ${LDFLAGS} \ -o ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} \ ${OBJECTS} ${GIRARA_OBJECTS_DEBUG} ${LIBS} debug: ${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} run-debug: debug ${XDG_HELPER} $(QUIET)./${BUILDDIR_DEBUG}/${BINDIR}/${PROJECT} # gcov ${OBJECTS_GCOV}: config.mk ../config.mk ../girara/version.h ${BUILDDIR_GCOV}/%.o: %.c @mkdir -p ${DEPENDDIR}/$(dir $(abspath $@)) @mkdir -p $(dir $(abspath $@)) $(call colorecho,CC,$<) $(QUIET)${CC} -c ${CPPFLAGS} ${CFLAGS} ${GCOV_CFLAGS} ${DFLAGS} ${GCOV_DFLAGS} \ -o $@ $< -MMD -MF ${DEPENDDIR}/$(abspath $@).dep ${BUILDDIR_GCOV}/${BINDIR}/${PROJECT}: ${OBJECTS_GCOV} $(QUIET)$(MAKE) -C .. gcov $(call colorecho,CC,$@) @mkdir -p ${BUILDDIR_GCOV}/${BINDIR} $(QUIET)${CC} ${SFLAGS} ${LDFLAGS} ${GCOV_CFLAGS} ${GCOV_LDFLAGS} \ -o ${BUILDDIR_GCOV}/${BINDIR}/${PROJECT} \ ${OBJECTS} ${GIRARA_OBJECTS_GCOV} ${LIBS} gcov: ${BUILDDIR_GCOV}/${BINDIR}/${PROJECT} run-gcov: gcov $(QUIET)./${BUILDDIR_GCOV}/${BINDIR}/${PROJECT} # XDG test helper ${XDG_HELPER}: ${XDG_HELPER_SOURCE} $(MAKE) -C .. release @mkdir -p ${DEPENDDIR}/$(dir $(abspath $@)) @mkdir -p $(dir $(abspath $@)) $(call colorecho,CC,$@) $(QUIET)${CC} ${CPPFLAGS} ${CFLAGS} -o $@ $< ${GIRARA_OBJECTS} \ ${LDFLAGS} ${LIBS} -MMD -MF ${DEPENDDIR}/$(abspath $@).dep clean: $(call colorecho,RM, "Clean test files") $(QUIET)rm -rf ${PROJECT} $(QUIET)rm -rf ${PROJECT}-debug $(QUIET)rm -rf ${PROJECT}-gcov $(QUIET)rm -rf ${BUILDDIR} $(QUIET)rm -rf ${DEPENDDIR} .PHONY: all clean debug gciv run run-debug run-gcov -include $(wildcard ${DEPENDDIR}/*.dep) girara-0.2.5/tests/config.mk0000644000175000017500000000045412513025726014375 0ustar mockmock# See LICENSE file for license and copyright information CHECK_INC ?= $(shell pkg-config --cflags check) CHECK_LIB ?= $(shell pkg-config --libs check) LIBS += ${CHECK_LIB} GIRARA_RELEASE=../${BUILDDIR_RELEASE}/girara GIRARA_DEBUG=../${BUILDDIR_DEBUG}/girara GIRARA_GCOV=../${BUILDDIR_GCOV}/girara girara-0.2.5/tests/test_config.c0000644000175000017500000000411412513025726015244 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include #include #include "session.h" #include "settings.h" #include "config.h" START_TEST(test_config_parse) { girara_session_t* session = girara_session_create(); fail_unless(session != NULL, "Failed to create girara session.", NULL); int default_val = 1; fail_unless(girara_setting_add(session, "test1", "default-string", STRING, false, NULL, NULL, NULL), "Failed to add setting 'test1'", NULL); fail_unless(girara_setting_add(session, "test2", &default_val, INT, false, NULL, NULL, NULL), "Failed to add setting 'test2'", NULL); char* filename = NULL; int fd = g_file_open_tmp(NULL, &filename, NULL); fail_unless(fd != -1 && filename != NULL, "Couldn't open temporary file.", NULL); GError* error = NULL; if (g_file_set_contents(filename, "set test1 config-string\n" \ "set test2 2\n", -1, &error) == FALSE) { fail_unless(false, "Couldn't set content: %s", error->message, NULL); g_error_free(error); } girara_config_parse(session, filename); char* ptr = NULL; fail_unless(girara_setting_get(session, "test1", &ptr), "Failed to get setting 'test1'.", NULL); fail_unless(g_strcmp0(ptr, "config-string") == 0, "Value of 'test1' doesn't match (got: %s, expected: %s", ptr, "config-string", NULL); g_free(ptr); int real_val = 0; fail_unless(girara_setting_get(session, "test2", &real_val), "Failed to get setting 'test1'.", NULL); fail_unless(real_val == 2, "Value of 'test2' doesn't match (got: %d, expected: %d", real_val, 2, NULL); close(fd); fail_unless(g_remove(filename) == 0, "Failed to remove temporary file.", NULL); g_free(filename); girara_session_destroy(session); } END_TEST extern void setup(void); Suite* suite_config() { TCase* tcase = NULL; Suite* suite = suite_create("Config"); /* parse */ tcase = tcase_create("parse"); tcase_add_checked_fixture(tcase, setup, NULL); tcase_add_test(tcase, test_config_parse); suite_add_tcase(suite, tcase); return suite; } girara-0.2.5/tests/test_datastructures.c0000644000175000017500000003430212512771304017055 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include #include static unsigned int list_free_called = 0; static unsigned int node_free_called = 0; static void list_free(void* data) { fail_unless(list_free_called == 0u, NULL); fail_unless((intptr_t) data == 0xDEAD, NULL); ++list_free_called; } START_TEST(test_datastructures_list) { girara_list_t* list = girara_list_new(); // size of empty list fail_unless(girara_list_size(list) == 0, NULL); // append for (intptr_t i = 0; i != 10; ++i) { girara_list_append(list, (void*)i); } // size of list fail_unless(girara_list_size(list) == 10, NULL); // iterator tests girara_list_iterator_t* iter = girara_list_iterator(list); fail_unless(iter != NULL, NULL); for (intptr_t i = 0; i != 10; ++i) { fail_unless(((intptr_t) girara_list_iterator_data(iter) == i), NULL); if (i < 9) { fail_unless((girara_list_iterator_is_valid(iter)), NULL); fail_unless((girara_list_iterator_has_next(iter)), NULL); fail_unless((girara_list_iterator_next(iter) != NULL), NULL); fail_unless((girara_list_iterator_is_valid(iter)), NULL); } else { fail_unless((girara_list_iterator_is_valid(iter)), NULL); fail_unless((!girara_list_iterator_has_next(iter)), NULL); fail_unless((girara_list_iterator_next(iter) == NULL), NULL); fail_unless((!girara_list_iterator_is_valid(iter)), NULL); } } girara_list_iterator_free(iter); girara_list_free(list); // contains list = girara_list_new(); for (intptr_t i = 0; i != 10; ++i) { fail_unless((girara_list_contains(list, (void*) i) == false), NULL); girara_list_append(list, (void*)i); fail_unless((girara_list_contains(list, (void*) i) == true), NULL); } // position for (intptr_t i = 0; i != 10; ++i) { fail_unless((girara_list_position(list, (void*) i) == i), NULL); } fail_unless((girara_list_position(list, (void*) 10) == -1), NULL); // remove for (intptr_t i = 9; i >= 0; --i) { fail_unless((girara_list_contains(list, (void*) i) == true), NULL); girara_list_remove(list, (void*)i); fail_unless((girara_list_contains(list, (void*)i) == false), NULL); girara_list_append(list, (void*)i); } iter = girara_list_iterator(list); fail_unless((iter != NULL), NULL); for (intptr_t i = 9; i >= 0; --i) { fail_unless(((intptr_t)girara_list_iterator_data(iter) == i), NULL); if (i > 0) { fail_unless((girara_list_iterator_is_valid(iter)), NULL); fail_unless((girara_list_iterator_has_next(iter)), NULL); fail_unless((girara_list_iterator_next(iter) != NULL), NULL); fail_unless((girara_list_iterator_is_valid(iter)), NULL); } else { fail_unless((girara_list_iterator_is_valid(iter)), NULL); fail_unless((!girara_list_iterator_has_next(iter)), NULL); fail_unless((girara_list_iterator_next(iter) == NULL), NULL); fail_unless((!girara_list_iterator_is_valid(iter)), NULL); } } girara_list_iterator_free(iter); girara_list_free(list); } END_TEST START_TEST(test_datastructures_list_merge) { girara_list_t* list1 = girara_list_new(); girara_list_t* list2 = girara_list_new(); fail_unless((list1 != NULL), NULL); fail_unless((list2 != NULL), NULL); fail_unless((girara_list_merge(NULL, NULL) == NULL), NULL); fail_unless((girara_list_merge(list1, NULL) == list1), NULL); fail_unless((girara_list_merge(NULL, list2) == list2), NULL); girara_list_append(list1, (void*)0); girara_list_append(list2, (void*)1); girara_list_t* list3 = girara_list_merge(list1, list2); fail_unless((list3 == list1), NULL); fail_unless((girara_list_nth(list3, 0) == (void*)0), NULL); fail_unless((girara_list_nth(list3, 1) == (void*)1), NULL); girara_list_free(list1); girara_list_free(list2); } END_TEST START_TEST(test_datastructures_list_free_empty) { // free empty list girara_list_t* list = girara_list_new(); fail_unless((list != NULL), NULL); girara_list_free(list); list = girara_list_new2(NULL); fail_unless((list != NULL), NULL); girara_list_free(list); list = girara_list_new2(g_free); fail_unless((list != NULL), NULL); girara_list_free(list); } END_TEST START_TEST(test_datastructures_list_free_already_cleared) { // free cleared list girara_list_t* list = girara_list_new(); fail_unless((list != NULL), NULL); girara_list_append(list, (void*) 0xDEAD); fail_unless((girara_list_size(list) == 1), NULL); girara_list_clear(list); fail_unless((girara_list_size(list) == 0), NULL); girara_list_free(list); } END_TEST START_TEST(test_datastructures_list_free_free_function) { // free function girara_list_t* list = girara_list_new(); list_free_called = 0; fail_unless((list != NULL), NULL); girara_list_set_free_function(list, list_free); girara_list_append(list, (void*) 0xDEAD); girara_list_free(list); fail_unless((list_free_called == 1), NULL); } END_TEST START_TEST(test_datastructures_list_free_free_function_remove) { // remove with free function list_free_called = 0; girara_list_t* list = girara_list_new2(list_free); fail_unless((list != NULL), NULL); girara_list_append(list, (void*)0xDEAD); girara_list_remove(list, (void*)0xDEAD); fail_unless((girara_list_size(list) == 0), NULL); girara_list_free(list); fail_unless((list_free_called == 1), NULL); } END_TEST START_TEST(test_datastructures_sorted_list_basic) { girara_list_t* list = girara_sorted_list_new(NULL); fail_unless((list != NULL), NULL); girara_list_free(list); } END_TEST START_TEST(test_datastructures_sorted_list) { girara_list_t* list = girara_sorted_list_new2((girara_compare_function_t) g_strcmp0, (girara_free_function_t) g_free); fail_unless((list != NULL), NULL); girara_list_t* unsorted_list = girara_list_new2((girara_free_function_t) g_free); fail_unless((unsorted_list != NULL), NULL); static const char* test_strings[] = { "A", "C", "Baa", "Za", "Bba", "Bab", NULL }; static const char* test_strings_sorted[] = { "A", "Baa", "Bab", "Bba", "C", "Za", NULL }; // append for (const char** p = test_strings; *p != NULL; ++p) { girara_list_append(list, (void*)g_strdup(*p)); girara_list_append(unsorted_list, (void*)g_strdup(*p)); } fail_unless((girara_list_size(list) == sizeof(test_strings) / sizeof(char*) - 1), NULL); fail_unless((girara_list_size(unsorted_list) == sizeof(test_strings) / sizeof(char*) - 1), NULL); // check sorting const char** p = test_strings_sorted; GIRARA_LIST_FOREACH(list, const char*, iter, value) fail_unless((g_strcmp0(value, *p) == 0), NULL); ++p; GIRARA_LIST_FOREACH_END(list, const char*, iter, value); girara_list_sort(unsorted_list, (girara_compare_function_t) g_strcmp0); p = test_strings_sorted; GIRARA_LIST_FOREACH(unsorted_list, const char*, iter, value) fail_unless((g_strcmp0(value, *p) == 0), NULL); ++p; GIRARA_LIST_FOREACH_END(unsorted_list, const char*, iter, value); girara_list_free(list); girara_list_free(unsorted_list); } END_TEST START_TEST(test_datastructures_list_iterator_remove) { girara_list_t* list = girara_list_new(); for (intptr_t i = 0; i != 10; ++i) { girara_list_append(list, (void*)i); } fail_unless(girara_list_size(list) == 10); intptr_t next = 0; GIRARA_LIST_FOREACH(list, intptr_t, iter, data) fail_unless(next++ == data); if (data == 5) { /* this is broken … this will cause an invalid read */ girara_list_remove(list, (void*) data); } GIRARA_LIST_FOREACH_END(list, intptr_t, iter, data); for (intptr_t s = 0; s != 5; ++s) { fail_unless((intptr_t)girara_list_nth(list, s) == s); } for (intptr_t s = 5; s != 9; ++s) { fail_unless((intptr_t)girara_list_nth(list, s) == s + 1); } } END_TEST static void node_free(void* data) { if (g_strcmp0((char*)data, "root") == 0) { fail_unless((node_free_called == 0), NULL); } else if (g_strcmp0((char*)data, "child") == 0) { fail_unless((node_free_called == 1), NULL); } else { fail("Should not be reached"); } ++node_free_called; } START_TEST(test_datastructures_node) { girara_tree_node_t* root = girara_node_new("root"); fail_unless((girara_node_get_num_children(root) == 0), NULL); fail_unless((girara_node_get_parent(root) == NULL), NULL); fail_unless((girara_node_get_root(root) == root), NULL); fail_unless((g_strcmp0((char*) girara_node_get_data(root), "root") == 0), NULL); girara_list_t* rchildren = girara_node_get_children(root); fail_unless((rchildren != NULL), NULL); fail_unless((girara_list_size(rchildren) == 0), NULL); girara_list_free(rchildren); girara_node_free(root); root = girara_node_new("root"); girara_node_set_free_function(root, node_free); girara_node_append_data(root, "child"); fail_unless((girara_node_get_num_children(root) == 1), NULL); fail_unless((node_free_called == 0), NULL); girara_node_free(root); fail_unless((node_free_called == 2), NULL); node_free_called = 0; root = girara_node_new("root"); girara_node_set_free_function(root, node_free); girara_node_set_data(root, "child"); fail_unless((node_free_called == 1), NULL); girara_node_free(root); fail_unless((node_free_called == 2), NULL); root = girara_node_new(g_strdup("root")); girara_node_set_free_function(root, g_free); for (unsigned int i = 0; i != 5; ++i) { girara_tree_node_t* child = girara_node_append_data(root, g_strdup_printf("child_%u", i)); for (unsigned int j = 0; j != 10; ++j) { girara_node_append_data(child, g_strdup_printf("child_%u_%u", i, j)); } fail_unless((girara_node_get_num_children(child) == 10), NULL); } fail_unless((girara_node_get_num_children(root) == 5), NULL); girara_list_t* children = girara_node_get_children(root); fail_unless((children != NULL), NULL); fail_unless((girara_list_size(children) == 5), NULL); unsigned int i = 0; girara_list_iterator_t* iter = girara_list_iterator(children); while (girara_list_iterator_is_valid(iter)) { char* expected = g_strdup_printf("child_%u", i); girara_tree_node_t* child = (girara_tree_node_t*)girara_list_iterator_data(iter); fail_unless((g_strcmp0((char*)girara_node_get_data(child), expected) == 0), NULL); fail_unless((girara_node_get_parent(child) == root), NULL); fail_unless((girara_node_get_root(child) == root), NULL); g_free(expected); girara_list_t* grandchildren = girara_node_get_children(child); fail_unless((grandchildren != NULL), NULL); fail_unless((girara_list_size(grandchildren) == 10), NULL); unsigned int j = 0; girara_list_iterator_t* iter2 = girara_list_iterator(grandchildren); while (girara_list_iterator_is_valid(iter2)) { char* expected = g_strdup_printf("child_%u_%u", i, j); girara_tree_node_t* gchild = (girara_tree_node_t*)girara_list_iterator_data(iter2); fail_unless((g_strcmp0((char*)girara_node_get_data(gchild), expected) == 0), NULL); fail_unless((girara_node_get_parent(gchild) == child), NULL); fail_unless((girara_node_get_root(gchild) == root), NULL); g_free(expected); ++j; girara_list_iterator_next(iter2); } fail_unless((j == 10), NULL); girara_list_iterator_free(iter2); girara_list_free(grandchildren); girara_list_iterator_next(iter); ++i; } fail_unless((i == 5), NULL); girara_list_iterator_free(iter); girara_list_free(children); girara_node_free(root); } END_TEST static int find_compare(const void* item, const void* data) { if (item == data) { return 1; } else { return 0; } } START_TEST(test_datastructures_list_find) { girara_list_t* list = girara_list_new(); fail_unless((list != NULL), NULL); /* test parameters */ fail_unless((girara_list_find(NULL, NULL, NULL) == NULL), NULL); fail_unless((girara_list_find(list, NULL, NULL) == NULL), NULL); fail_unless((girara_list_find(NULL, NULL, (void*) 0xDEAD) == NULL), NULL); fail_unless((girara_list_find(NULL, find_compare, NULL) == NULL), NULL); /* test functionality */ girara_list_append(list, (void*) 0xDEAD); fail_unless((girara_list_find(list, find_compare, (void*) 0xDEAD) == NULL), NULL); fail_unless((girara_list_find(list, find_compare, (void*) 0xCAFE) != NULL), NULL); girara_list_free(list); } END_TEST START_TEST(test_datastructures_list_prepend) { girara_list_t* list = girara_list_new(); fail_unless((list != NULL), NULL); /* test parameters */ girara_list_prepend(list, NULL); fail_unless((girara_list_size(list) != 0), NULL); girara_list_free(list); } END_TEST Suite* suite_datastructures() { TCase* tcase = NULL; Suite* suite = suite_create("Datastructures"); /* list free */ tcase = tcase_create("list_free_function"); tcase_add_test(tcase, test_datastructures_list_free_empty); tcase_add_test(tcase, test_datastructures_list_free_already_cleared); tcase_add_test(tcase, test_datastructures_list_free_free_function); tcase_add_test(tcase, test_datastructures_list_free_free_function_remove); suite_add_tcase(suite, tcase); /* list create */ tcase = tcase_create("list_basics"); tcase_add_test(tcase, test_datastructures_list); suite_add_tcase(suite, tcase); /* sorted list */ tcase = tcase_create("list_sorted"); tcase_add_test(tcase, test_datastructures_sorted_list_basic); tcase_add_test(tcase, test_datastructures_sorted_list); suite_add_tcase(suite, tcase); /* merge lists */ tcase = tcase_create("list_merge"); tcase_add_test(tcase, test_datastructures_list_merge); suite_add_tcase(suite, tcase); /* search lists */ tcase = tcase_create("list_find"); tcase_add_test(tcase, test_datastructures_list_find); suite_add_tcase(suite, tcase); /* prepend lists */ tcase = tcase_create("list_prepend"); tcase_add_test(tcase, test_datastructures_list_prepend); suite_add_tcase(suite, tcase); /* list iterators */ tcase = tcase_create("list_iterators"); /* tcase_add_test(tcase, test_datastructures_list_iterator_remove); */ suite_add_tcase(suite, tcase); /* node free */ tcase = tcase_create("node_free"); tcase_add_test(tcase, test_datastructures_sorted_list); suite_add_tcase(suite, tcase); /* node basics */ tcase = tcase_create("node_basics"); tcase_add_test(tcase, test_datastructures_node); suite_add_tcase(suite, tcase); return suite; } girara-0.2.5/tests/test_session.c0000644000175000017500000000163612513025726015470 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include "session.h" START_TEST(test_create) { girara_session_t* session = girara_session_create(); fail_unless(session != NULL, "Could not create session"); girara_session_destroy(session); } END_TEST START_TEST(test_init) { girara_session_t* session = girara_session_create(); fail_unless(session != NULL, "Could not create session"); bool result = girara_session_init(session, NULL); fail_unless(result == true, "Could not init session"); girara_session_destroy(session); } END_TEST extern void setup(void); Suite* suite_session() { TCase* tcase = NULL; Suite* suite = suite_create("Session"); /* basic */ tcase = tcase_create("basic"); tcase_add_checked_fixture(tcase, setup, NULL); tcase_add_test(tcase, test_create); tcase_add_test(tcase, test_init); suite_add_tcase(suite, tcase); return suite; } girara-0.2.5/tests/test_setting.c0000644000175000017500000000552712513025726015465 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include "session.h" #include "settings.h" START_TEST(test_settings_basic) { girara_session_t* session = girara_session_create(); fail_unless(session != NULL, "Couldn't create session.", NULL); fail_unless(girara_setting_add(session, "test", NULL, STRING, false, NULL, NULL, NULL), NULL); char* ptr = NULL; fail_unless(girara_setting_get(session, "test", &ptr), NULL); fail_unless(ptr == NULL, NULL); fail_unless(girara_setting_set(session, "test", "value"), NULL); fail_unless(girara_setting_get(session, "test", &ptr), NULL); fail_unless(g_strcmp0(ptr, "value") == 0, NULL); g_free(ptr); ptr = NULL; fail_unless(!girara_setting_get(session, "does-not-exist", &ptr), NULL); fail_unless(ptr == NULL, NULL); fail_unless(girara_setting_add(session, "test2", "value", STRING, false, NULL, NULL, NULL), NULL); fail_unless(girara_setting_get(session, "test2", &ptr), NULL); fail_unless(g_strcmp0(ptr, "value") == 0, NULL); g_free(ptr); ptr = NULL; fail_unless(!girara_setting_add(session, "test3", NULL, INT, false, NULL, NULL, NULL), NULL); fail_unless(!girara_setting_get(session, "test3", &ptr), NULL); fail_unless(ptr == NULL, NULL); float val = 0.0, rval = 0.0; fail_unless(girara_setting_add(session, "test4", &val, FLOAT, false, NULL, NULL, NULL), NULL); fail_unless(girara_setting_get(session, "test4", &rval), NULL); fail_unless(val == rval, NULL); girara_session_destroy(session); } END_TEST static int callback_called = 0; static void setting_callback(girara_session_t* session, const char* name, girara_setting_type_t type, void* value, void* data) { fail_unless(callback_called == 0, NULL); fail_unless(session != NULL, NULL); fail_unless(g_strcmp0(name, "test") == 0, NULL); fail_unless(type == STRING, NULL); fail_unless(g_strcmp0(value, "value") == 0, NULL); fail_unless(g_strcmp0(data, "data") == 0, NULL); callback_called++; } START_TEST(test_settings_callback) { girara_session_t* session = girara_session_create(); fail_unless(session != NULL, NULL); fail_unless(girara_setting_add(session, "test", "oldvalue", STRING, false, NULL, setting_callback, "data"), NULL); fail_unless(girara_setting_set(session, "test", "value"), NULL); fail_unless(callback_called == 1, NULL); girara_session_destroy(session); } END_TEST extern void setup(void); Suite* suite_settings() { TCase* tcase = NULL; Suite* suite = suite_create("Settings"); /* basic */ tcase = tcase_create("basic"); tcase_add_checked_fixture(tcase, setup, NULL); tcase_add_test(tcase, test_settings_basic); suite_add_tcase(suite, tcase); /* callback */ tcase = tcase_create("callback"); tcase_add_checked_fixture(tcase, setup, NULL); suite_add_tcase(suite, tcase); tcase_add_test(tcase, test_settings_callback); return suite; } girara-0.2.5/tests/test_template.c0000644000175000017500000001063712513025726015621 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include "template.h" #include "datastructures.h" START_TEST(test_new) { GiraraTemplate* obj = girara_template_new(NULL); ck_assert_ptr_ne(obj, NULL); g_object_unref(obj); obj = girara_template_new("base"); ck_assert_ptr_ne(obj, NULL); g_object_unref(obj); } END_TEST START_TEST(test_new_with_null) { GiraraTemplate* obj = girara_template_new(NULL); ck_assert_ptr_ne(obj, NULL); const char* base = girara_template_get_base(obj); ck_assert_str_eq((char*) base, ""); g_object_unref(obj); } END_TEST START_TEST(test_new_with_base) { GiraraTemplate* obj = girara_template_new("base"); ck_assert_ptr_ne(obj, NULL); const char* base = girara_template_get_base(obj); ck_assert_str_eq((char*) base, "base"); g_object_unref(obj); } END_TEST START_TEST(test_base_variables_none) { GiraraTemplate* obj = girara_template_new("base"); ck_assert_ptr_ne(obj, NULL); girara_list_t* variables = girara_template_referenced_variables(obj); ck_assert_uint_eq(girara_list_size(variables), 0); g_object_unref(obj); } END_TEST START_TEST(test_base_variables_one) { GiraraTemplate* obj = girara_template_new("@test@"); ck_assert_ptr_ne(obj, NULL); girara_list_t* variables = girara_template_referenced_variables(obj); ck_assert_uint_eq(girara_list_size(variables), 1); char* variable = girara_list_nth(variables, 0); ck_assert_str_eq(variable, "test"); g_object_unref(obj); } END_TEST START_TEST(test_base_variables_one_twice) { GiraraTemplate* obj = girara_template_new("@test@ @test@"); ck_assert_ptr_ne(obj, NULL); girara_list_t* variables = girara_template_referenced_variables(obj); ck_assert_uint_eq(girara_list_size(variables), 1); g_object_unref(obj); } END_TEST START_TEST(test_variable_add) { GiraraTemplate* obj = girara_template_new(NULL); ck_assert_ptr_ne(obj, NULL); ck_assert(girara_template_add_variable(obj, "name")); g_object_unref(obj); } END_TEST START_TEST(test_variable_add_invalid) { GiraraTemplate* obj = girara_template_new(NULL); ck_assert_ptr_ne(obj, NULL); ck_assert(!girara_template_add_variable(obj, "na|me")); g_object_unref(obj); } END_TEST START_TEST(test_variable_set) { GiraraTemplate* obj = girara_template_new(NULL); ck_assert_ptr_ne(obj, NULL); ck_assert(girara_template_add_variable(obj, "name")); girara_template_set_variable_value(obj, "name", "value"); g_object_unref(obj); } END_TEST START_TEST(test_full_1) { GiraraTemplate* obj = girara_template_new("name = @name@"); ck_assert_ptr_ne(obj, NULL); ck_assert(girara_template_add_variable(obj, "name")); girara_template_set_variable_value(obj, "name", "value"); char* result = girara_template_evaluate(obj); ck_assert_ptr_ne(result, NULL); ck_assert_str_eq(result, "name = value"); g_free(result); g_object_unref(obj); } END_TEST START_TEST(test_full_2) { GiraraTemplate* obj = girara_template_new("name = @name@; test = @test@"); ck_assert_ptr_ne(obj, NULL); girara_template_add_variable(obj, "name"); girara_template_set_variable_value(obj, "name", "value"); char* result = girara_template_evaluate(obj); ck_assert_ptr_eq(result, NULL); g_object_unref(obj); } END_TEST extern void setup(void); Suite* suite_template() { TCase* tcase = NULL; Suite* suite = suite_create("Template"); /* girara_template_new */ tcase = tcase_create("object creation"); tcase_add_checked_fixture(tcase, setup, NULL); tcase_add_test(tcase, test_new); tcase_add_test(tcase, test_new_with_null); tcase_add_test(tcase, test_new_with_base); suite_add_tcase(suite, tcase); /* base processing */ tcase = tcase_create("base processing"); tcase_add_checked_fixture(tcase, setup, NULL); tcase_add_test(tcase, test_base_variables_none); tcase_add_test(tcase, test_base_variables_one); tcase_add_test(tcase, test_base_variables_one_twice); suite_add_tcase(suite, tcase); /* basic variable operations */ tcase = tcase_create("variables"); tcase_add_checked_fixture(tcase, setup, NULL); tcase_add_test(tcase, test_variable_add); tcase_add_test(tcase, test_variable_add_invalid); tcase_add_test(tcase, test_variable_set); suite_add_tcase(suite, tcase); /* full processing */ tcase = tcase_create("full"); tcase_add_checked_fixture(tcase, setup, NULL); tcase_add_test(tcase, test_full_1); tcase_add_test(tcase, test_full_2); suite_add_tcase(suite, tcase); return suite; } girara-0.2.5/tests/test_utils.c0000644000175000017500000002574212513025726015151 0ustar mockmock// See LICENSE file for license and copyright information #define _BSD_SOURCE #if !defined(__OpenBSD__) && !defined(__FreeBSD__) && !defined(__NetBSD__) #define _POSIX_SOURCE #endif #include #include #include #include #include #include #include #include #include #include "utils.h" #include "datastructures.h" static girara_list_t* read_pwd_info(void) { girara_list_t* list = girara_list_new(); girara_list_set_free_function(list, g_free); struct passwd* pw; errno = 0; while ((pw = getpwent()) != NULL) { girara_list_append(list, g_strdup(pw->pw_name)); errno = 0; } fail_unless(errno == 0, "Non-zero errno :%d", errno, NULL); endpwent(); return list; } START_TEST(test_home_directory) { const gchar* user = g_get_home_dir(); gchar* oldenv = g_getenv("HOME") ? g_strdup(g_getenv("HOME")) : NULL; if (oldenv) { gchar* result = girara_get_home_directory(NULL); fail_unless(result != oldenv, "Home directory is not the same", NULL); g_free(result); } g_unsetenv("HOME"); gchar* result = girara_get_home_directory(NULL); fail_unless(result != user, "Home directory is not the same", NULL); g_free(result); girara_list_t* list = read_pwd_info(); girara_list_iterator_t* iter = girara_list_iterator(list); fail_unless(iter != NULL, "Could not create iterator", NULL); while (girara_list_iterator_is_valid(iter)) { const char* username = (const char*) girara_list_iterator_data(iter); gchar* result = girara_get_home_directory(username); fail_unless(result != NULL && strlen(result) != 0, "Home directory is empty", NULL); g_free(result); girara_list_iterator_next(iter); } girara_list_iterator_free(iter); girara_list_free(list); if (oldenv) { g_setenv("HOME", oldenv, TRUE); g_free(oldenv); } } END_TEST START_TEST(test_home_directory_set_HOME) { g_setenv("HOME", "/home/test", TRUE); char* result = girara_get_home_directory(NULL); fail_unless(g_strcmp0(result, "/home/test") == 0, "Home directory is not the same", NULL); g_free(result); } END_TEST START_TEST(test_fix_path_basic) { gchar* result = girara_fix_path("test"); fail_unless(g_strcmp0(result, "test") == 0, "Fix path result does not match (got: %s, expected: %s)", result, "test", NULL); g_free(result); result = girara_fix_path("test/test"); fail_unless(g_strcmp0(result, "test/test") == 0, "Fix path result does not match (got: %s, expected: %s)", result, "test/test", NULL); g_free(result); } END_TEST START_TEST(test_fix_path_extended) { gchar* oldenv = g_getenv("HOME") ? g_strdup(g_getenv("HOME")) : NULL; g_unsetenv("HOME"); girara_list_t* list = read_pwd_info(); GIRARA_LIST_FOREACH(list, const char*, iter, username) gchar* path = g_strdup_printf("~%s/test", username); gchar* result = girara_fix_path(path); fail_unless(result != NULL && strlen(result) != 0, "Fix path result is empty"); g_free(result); g_free(path); GIRARA_LIST_FOREACH_END(list, const char*, iter, pwdinfo); girara_list_free(list); if (oldenv) { g_setenv("HOME", oldenv, TRUE); g_free(oldenv); } } END_TEST static void xdg_path_impl(girara_xdg_path_t path, const gchar* envvar, const gchar* expected) { #if GLIB_CHECK_VERSION(2, 35, 3) const gchar* home = g_getenv("HOME"); gchar* home_env_var = NULL; gchar** envp = NULL; if (home != NULL) { home_env_var = g_strdup_printf("HOME=%s", home); envp = calloc(3, sizeof(gchar*)); fail_unless(envp != NULL, "Failed to allocate memory for ENV"); envp[1] = home_env_var; } else { envp = calloc(2, sizeof(gchar*)); fail_unless(envp != NULL, "Failed to allocate memory for ENV"); } envp[0] = g_strdup_printf("%s=", envvar); #else gchar* envp[] = { g_strdup_printf("%s=", envvar), NULL }; #endif gchar* argv[] = { XDG_TEST_HELPER, g_strdup_printf("%d", path), NULL }; gchar* output = NULL; bool result = g_spawn_sync(NULL, argv, envp, G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL, &output, NULL, NULL, NULL); g_assert(result); g_assert(output); fail_unless(g_strcmp0(output, expected) == 0, "Output is not the same (got: %s, expected: %s)", output, expected, NULL); g_free(output); g_free(envp[0]); envp[0] = g_strdup_printf("%s=~/xdg", envvar); result = g_spawn_sync(NULL, argv, envp, G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL, &output, NULL, NULL, NULL); g_assert(result); g_assert(output); fail_unless(g_strcmp0(output, "~/xdg") == 0, "Output is not the same (got: %s, expected: %s)", output, "~/xdg", NULL); g_free(envp[0]); envp[0] = g_strdup_printf("%s=/home/test/xdg", envvar); result= g_spawn_sync(NULL, argv, envp, G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL, &output, NULL, NULL, NULL); g_assert(result); g_assert(output); fail_unless(g_strcmp0(output, "/home/test/xdg") == 0, "Output is not the same (got: %s, expected: %s)", output, "/home/test/xdg", NULL); g_free(envp[0]); g_free(argv[1]); #if GLIB_CHECK_VERSION(2, 35, 3) g_free(home_env_var); g_free(envp); #endif } START_TEST(test_xdg_path) { xdg_path_impl(XDG_CONFIG, "XDG_CONFIG_HOME", g_get_user_config_dir()); xdg_path_impl(XDG_DATA, "XDG_DATA_HOME", g_get_user_data_dir()); xdg_path_impl(XDG_CONFIG_DIRS, "XDG_CONFIG_DIRS", "/etc/xdg"); xdg_path_impl(XDG_DATA_DIRS, "XDG_DATA_DIRS", "/usr/local/share/:/usr/share"); xdg_path_impl(XDG_CACHE, "XDG_CACHE_HOME", g_get_user_cache_dir()); } END_TEST START_TEST(test_file_invariants) { fail_unless(girara_file_open(NULL, NULL) == NULL, NULL); fail_unless(girara_file_open("somefile", NULL) == NULL, NULL); fail_unless(girara_file_open(NULL, "r") == NULL, NULL); fail_unless(girara_file_read_line(NULL) == NULL, NULL); fail_unless(girara_file_read(NULL) == NULL, NULL); } END_TEST START_TEST(test_file_read) { static const char CONTENT[] = "test1\ntest2\ntest3"; static const char* LINES[] = { "test1", "test2", "test3" }; static size_t NUMLINES = 3; gchar* path = NULL; int fd = g_file_open_tmp("girara.test.XXXXXX", &path, NULL); fail_unless(fd != -1, "Failed to open temporary file.", NULL); fail_unless(g_strcmp0(path, "") != 0, "Failed to open temporary file.", NULL); GError* error = NULL; if (g_file_set_contents(path, CONTENT, -1, &error) == FALSE) { fail_unless(false, "Couldn't set content: %s", error->message, NULL); g_error_free(error); } char* content = girara_file_read(path); fail_unless(g_strcmp0(content, CONTENT) == 0, "Reading file failed", NULL); free(content); FILE* file = girara_file_open(path, "r"); fail_unless(file != NULL, NULL); for (size_t i = 0; i != NUMLINES; ++i) { char* line = girara_file_read_line(file); fail_unless(g_strcmp0(line, LINES[i]) == 0, "Line doesn't match (got: %s, expected: %s)", line, LINES[i], NULL); g_free(line); } fclose(file); close(fd); fail_unless(g_remove(path) == 0, "Failed to remove temporary file.", NULL); g_free(path); } END_TEST START_TEST(test_safe_realloc) { fail_unless(girara_safe_realloc(NULL, 0u) == NULL, NULL); void* ptr = NULL; fail_unless(girara_safe_realloc(&ptr, sizeof(int)) != NULL, NULL); fail_unless(ptr != NULL, NULL); fail_unless(girara_safe_realloc(&ptr, 1024*sizeof(int)) != NULL, NULL); fail_unless(ptr != NULL, NULL); fail_unless(girara_safe_realloc(&ptr, 0u) == NULL, NULL); fail_unless(ptr == NULL, NULL); } END_TEST START_TEST(test_split_path) { fail_unless(girara_split_path_array(NULL) == NULL, NULL); fail_unless(girara_split_path_array("") == NULL, NULL); girara_list_t* res = girara_split_path_array("one/path"); fail_unless(res != NULL, NULL); fail_unless(girara_list_size(res) == 1, NULL); fail_unless(g_strcmp0(girara_list_nth(res, 0), "one/path") == 0, NULL); girara_list_free(res); res = girara_split_path_array("first/path:second/path"); fail_unless(res != NULL, NULL); fail_unless(girara_list_size(res) == 2, NULL); fail_unless(g_strcmp0(girara_list_nth(res, 0), "first/path") == 0, NULL); fail_unless(g_strcmp0(girara_list_nth(res, 1), "second/path") == 0, NULL); girara_list_free(res); } END_TEST START_TEST(test_strings_replace_substrings_invalid) { fail_unless(girara_replace_substring(NULL, NULL, NULL) == NULL); fail_unless(girara_replace_substring("", NULL, NULL) == NULL); fail_unless(girara_replace_substring("", "", NULL) == NULL); } END_TEST START_TEST(test_strings_replace_substrings_nothing_to_replace) { char* result = girara_replace_substring("test", "n", "y"); fail_unless(result != NULL); fail_unless(strncmp(result, "test", 5) == 0); g_free(result); } END_TEST START_TEST(test_strings_replace_substrings_1) { char* result = girara_replace_substring("test", "e", "f"); fail_unless(result != NULL); fail_unless(strncmp(result, "tfst", 5) == 0); g_free(result); } END_TEST START_TEST(test_strings_replace_substrings_2) { char* result = girara_replace_substring("test", "es", "f"); fail_unless(result != NULL); fail_unless(strncmp(result, "tft", 4) == 0); g_free(result); } END_TEST START_TEST(test_strings_replace_substrings_3) { char* result = girara_replace_substring("test", "e", "fg"); fail_unless(result != NULL); fail_unless(strncmp(result, "tfgst", 6) == 0); g_free(result); } END_TEST START_TEST(test_strings_replace_substrings_4) { char* result = girara_replace_substring("test test", "t", "es"); fail_unless(result != NULL); fail_unless(strncmp(result, "eseses eseses", 14) == 0); g_free(result); } END_TEST Suite* suite_utils() { TCase* tcase = NULL; Suite* suite = suite_create("Utils"); /* home directory */ tcase = tcase_create("home_directory"); tcase_add_test(tcase, test_home_directory); tcase_add_test(tcase, test_home_directory_set_HOME); suite_add_tcase(suite, tcase); /* fix path */ tcase = tcase_create("fix_path"); tcase_add_test(tcase, test_fix_path_basic); tcase_add_test(tcase, test_fix_path_extended); suite_add_tcase(suite, tcase); /* xdg path */ tcase = tcase_create("xdg_path"); tcase_add_test(tcase, test_xdg_path); suite_add_tcase(suite, tcase); /* file invariants */ tcase = tcase_create("file_invariants"); tcase_add_test(tcase, test_file_invariants); suite_add_tcase(suite, tcase); /* read file */ tcase = tcase_create("file_read"); tcase_add_test(tcase, test_file_read); suite_add_tcase(suite, tcase); /* safe realloc */ tcase = tcase_create("safe_realloc"); tcase_add_test(tcase, test_safe_realloc); suite_add_tcase(suite, tcase); /* split path */ tcase = tcase_create("split_path"); tcase_add_test(tcase, test_split_path); suite_add_tcase(suite, tcase); /* strings */ tcase = tcase_create("strings"); tcase_add_test(tcase, test_strings_replace_substrings_invalid); tcase_add_test(tcase, test_strings_replace_substrings_nothing_to_replace); tcase_add_test(tcase, test_strings_replace_substrings_1); tcase_add_test(tcase, test_strings_replace_substrings_2); tcase_add_test(tcase, test_strings_replace_substrings_3); suite_add_tcase(suite, tcase); return suite; } girara-0.2.5/tests/tests.c0000644000175000017500000000350312512771304014102 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include Suite* suite_utils(); Suite* suite_datastructures(); Suite* suite_settings(); Suite* suite_session(); Suite* suite_config(); Suite* suite_template(); void setup(void) { gtk_init(NULL, NULL); } int main() { Suite* suite = NULL; SRunner* suite_runner = NULL; int number_failed = 0; /* test utils */ suite = suite_utils(); suite_runner = srunner_create(suite); srunner_run_all(suite_runner, CK_NORMAL); number_failed += srunner_ntests_failed(suite_runner); srunner_free(suite_runner); /* test datastructures */ suite = suite_datastructures(); suite_runner = srunner_create(suite); srunner_run_all(suite_runner, CK_NORMAL); number_failed += srunner_ntests_failed(suite_runner); srunner_free(suite_runner); /* test settings */ suite = suite_settings(); suite_runner = srunner_create(suite); srunner_run_all(suite_runner, CK_NORMAL); number_failed += srunner_ntests_failed(suite_runner); srunner_free(suite_runner); /* test config */ suite = suite_config(); suite_runner = srunner_create(suite); srunner_run_all(suite_runner, CK_NORMAL); number_failed += srunner_ntests_failed(suite_runner); srunner_free(suite_runner); /* test session */ suite = suite_session(); suite_runner = srunner_create(suite); srunner_run_all(suite_runner, CK_NORMAL); number_failed += srunner_ntests_failed(suite_runner); srunner_free(suite_runner); /* test template */ suite = suite_template(); suite_runner = srunner_create(suite); srunner_run_all(suite_runner, CK_NORMAL); number_failed += srunner_ntests_failed(suite_runner); srunner_free(suite_runner); return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; } girara-0.2.5/tests/xdg_test_helper.c0000644000175000017500000000057312512771304016124 0ustar mockmock/* See LICENSE file for license and copyright information */ #include #include #include int main(int argc, char** argv) { if (argc != 2) { return -1; } if (strlen(argv[1]) != 1) { return -2; } const char* tmp = girara_get_xdg_path(argv[1][0] - '0'); if (tmp == NULL) { return -3; } printf("%s", tmp); return 0; }