From f7e7a923aca8be643f9ae6f7252f9fb27b3d2c3b Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sat, 3 Dec 2011 11:05:10 -0600 Subject: Second part of prior commit --- tde-i18n-it/docs/tdebase/kate/Makefile.am | 4 + tde-i18n-it/docs/tdebase/kate/Makefile.in | 635 +++++ tde-i18n-it/docs/tdebase/kate/advanced.docbook | 2336 ++++++++++++++++++ tde-i18n-it/docs/tdebase/kate/configuring.docbook | 2606 ++++++++++++++++++++ tde-i18n-it/docs/tdebase/kate/fundamentals.docbook | 1089 ++++++++ tde-i18n-it/docs/tdebase/kate/highlighting.docbook | 1380 +++++++++++ tde-i18n-it/docs/tdebase/kate/index.cache.bz2 | Bin 0 -> 59582 bytes tde-i18n-it/docs/tdebase/kate/index.docbook | 496 ++++ tde-i18n-it/docs/tdebase/kate/man-kate.1.docbook | 294 +++ tde-i18n-it/docs/tdebase/kate/mdi.docbook | 366 +++ tde-i18n-it/docs/tdebase/kate/menus.docbook | 2224 +++++++++++++++++ tde-i18n-it/docs/tdebase/kate/part.docbook | 988 ++++++++ tde-i18n-it/docs/tdebase/kate/plugins.docbook | 39 + .../docs/tdebase/kate/regular-expressions.docbook | 1216 +++++++++ 14 files changed, 13673 insertions(+) create mode 100644 tde-i18n-it/docs/tdebase/kate/Makefile.am create mode 100644 tde-i18n-it/docs/tdebase/kate/Makefile.in create mode 100644 tde-i18n-it/docs/tdebase/kate/advanced.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/configuring.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/fundamentals.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/highlighting.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/index.cache.bz2 create mode 100644 tde-i18n-it/docs/tdebase/kate/index.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/man-kate.1.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/mdi.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/menus.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/part.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/plugins.docbook create mode 100644 tde-i18n-it/docs/tdebase/kate/regular-expressions.docbook (limited to 'tde-i18n-it/docs/tdebase/kate') diff --git a/tde-i18n-it/docs/tdebase/kate/Makefile.am b/tde-i18n-it/docs/tdebase/kate/Makefile.am new file mode 100644 index 00000000000..aa6dfafb23e --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/Makefile.am @@ -0,0 +1,4 @@ +KDE_LANG = it +SUBDIRS = $(AUTODIRS) +KDE_DOCS = kate +KDE_MANS = AUTO diff --git a/tde-i18n-it/docs/tdebase/kate/Makefile.in b/tde-i18n-it/docs/tdebase/kate/Makefile.in new file mode 100644 index 00000000000..209e8327360 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/Makefile.in @@ -0,0 +1,635 @@ +# Makefile.in generated by automake 1.10.1 from Makefile.am. +# KDE tags expanded automatically by am_edit - $Revision: 483858 $ +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +subdir = docs/tdebase/kate +DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \ + $(top_srcdir)/configure.in +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +SOURCES = +DIST_SOURCES = +#>- RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ +#>- html-recursive info-recursive install-data-recursive \ +#>- install-dvi-recursive install-exec-recursive \ +#>- install-html-recursive install-info-recursive \ +#>- install-pdf-recursive install-ps-recursive install-recursive \ +#>- installcheck-recursive installdirs-recursive pdf-recursive \ +#>- ps-recursive uninstall-recursive +#>+ 7 +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive nmcheck-recursive bcheck-recursive +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = $(SUBDIRS) +#>- DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +#>+ 1 +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) $(KDE_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +ARTSCCONFIG = @ARTSCCONFIG@ +AUTOCONF = @AUTOCONF@ +AUTODIRS = @AUTODIRS@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CONF_FILES = @CONF_FILES@ +CYGPATH_W = @CYGPATH_W@ +DCOPIDL = @DCOPIDL@ +DCOPIDL2CPP = @DCOPIDL2CPP@ +DCOPIDLNG = @DCOPIDLNG@ +DCOP_DEPENDENCIES = @DCOP_DEPENDENCIES@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +GMSGFMT = @GMSGFMT@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +KCFG_DEPENDENCIES = @KCFG_DEPENDENCIES@ +KCONFIG_COMPILER = @KCONFIG_COMPILER@ +KDECONFIG = @KDECONFIG@ +KDE_EXTRA_RPATH = @KDE_EXTRA_RPATH@ +KDE_RPATH = @KDE_RPATH@ +KDE_XSL_STYLESHEET = @KDE_XSL_STYLESHEET@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MAKEKDEWIDGETS = @MAKEKDEWIDGETS@ +MCOPIDL = @MCOPIDL@ +MEINPROC = @MEINPROC@ +MKDIR_P = @MKDIR_P@ +MSGFMT = @MSGFMT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TOPSUBDIRS = @TOPSUBDIRS@ +VERSION = @VERSION@ +XGETTEXT = @XGETTEXT@ +XMLLINT = @XMLLINT@ +X_RPATH = @X_RPATH@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +#>- bindir = @bindir@ +#>+ 2 +DEPDIR = .deps +bindir = @bindir@ +build_alias = @build_alias@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host_alias = @host_alias@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +kde_appsdir = @kde_appsdir@ +kde_bindir = @kde_bindir@ +kde_confdir = @kde_confdir@ +kde_datadir = @kde_datadir@ +kde_htmldir = @kde_htmldir@ +kde_icondir = @kde_icondir@ +kde_kcfgdir = @kde_kcfgdir@ +kde_libs_htmldir = @kde_libs_htmldir@ +kde_libs_prefix = @kde_libs_prefix@ +kde_locale = @kde_locale@ +kde_mimedir = @kde_mimedir@ +kde_moduledir = @kde_moduledir@ +kde_servicesdir = @kde_servicesdir@ +kde_servicetypesdir = @kde_servicetypesdir@ +kde_sounddir = @kde_sounddir@ +kde_styledir = @kde_styledir@ +kde_templatesdir = @kde_templatesdir@ +kde_wallpaperdir = @kde_wallpaperdir@ +kde_widgetdir = @kde_widgetdir@ +tdeinitdir = @tdeinitdir@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +xdg_appsdir = @xdg_appsdir@ +xdg_directorydir = @xdg_directorydir@ +xdg_menudir = @xdg_menudir@ +KDE_LANG = it +#>- SUBDIRS = $(AUTODIRS) +#>+ 1 +SUBDIRS =. +KDE_DOCS = kate +KDE_MANS = AUTO +#>- all: all-recursive +#>+ 1 +all: docs-am all-recursive + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) +#>- @for dep in $?; do \ +#>- case '$(am__configure_deps)' in \ +#>- *$$dep*) \ +#>- cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ +#>- && exit 0; \ +#>- exit 1;; \ +#>- esac; \ +#>- done; \ +#>- echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/tdebase/kate/Makefile'; \ +#>- cd $(top_srcdir) && \ +#>- $(AUTOMAKE) --gnu docs/tdebase/kate/Makefile +#>+ 12 + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/tdebase/kate/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/tdebase/kate/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/tdebase/kate/Makefile.in +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +# This directory's subdirectories are mostly independent; you can cd +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. +$(RECURSIVE_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +$(RECURSIVE_CLEAN_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + rev=''; for subdir in $$list; do \ + if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ + fi; \ + done; \ + rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonemtpy = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +#>- distdir: $(DISTFILES) +#>+ 1 +distdir: distdir-nls $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done + list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + distdir=`$(am__cd) $(distdir) && pwd`; \ + top_distdir=`$(am__cd) $(top_distdir) && pwd`; \ + (cd $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$top_distdir" \ + distdir="$$distdir/$$subdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + distdir) \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-recursive +all-am: Makefile +installdirs: installdirs-recursive +installdirs-am: +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +#>- uninstall: uninstall-recursive +#>+ 1 +uninstall: uninstall-docs uninstall-nls uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +#>- clean: clean-recursive +#>+ 1 +clean: kde-rpo-clean clean-recursive + +#>- clean-am: clean-generic mostlyclean-am +#>+ 1 +clean-am: clean-docs clean-bcheck clean-generic mostlyclean-am + +distclean: distclean-recursive + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +info: info-recursive + +info-am: + +#>- install-data-am: +#>+ 1 +install-data-am: install-docs install-nls + +install-dvi: install-dvi-recursive + +install-exec-am: + +install-html: install-html-recursive + +install-info: install-info-recursive + +install-man: + +install-pdf: install-pdf-recursive + +install-ps: install-ps-recursive + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: + +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) install-am \ + install-strip + +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am check check-am clean clean-generic ctags \ + ctags-recursive distclean distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-pdf install-pdf-am install-ps install-ps-am \ + install-strip installcheck installcheck-am installdirs \ + installdirs-am maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-generic pdf pdf-am ps ps-am tags \ + tags-recursive uninstall uninstall-am + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: + +#>+ 2 +KDE_DIST=fundamentals.docbook configuring.docbook Makefile.in man-kate.1.docbook plugins.docbook index.docbook part.docbook highlighting.docbook menus.docbook advanced.docbook regular-expressions.docbook Makefile.am mdi.docbook index.cache.bz2 + +#>+ 24 +index.cache.bz2: $(srcdir)/index.docbook $(KDE_XSL_STYLESHEET) regular-expressions.docbook man-kate.1.docbook part.docbook mdi.docbook index.docbook menus.docbook advanced.docbook fundamentals.docbook configuring.docbook plugins.docbook highlighting.docbook + @if test -n "$(MEINPROC)"; then echo $(MEINPROC) --check --cache index.cache.bz2 $(srcdir)/index.docbook; $(MEINPROC) --check --cache index.cache.bz2 $(srcdir)/index.docbook; fi + +docs-am: index.cache.bz2 + +install-docs: docs-am install-nls + $(mkinstalldirs) $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate + @if test -f index.cache.bz2; then \ + echo $(INSTALL_DATA) index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/; \ + $(INSTALL_DATA) index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/; \ + elif test -f $(srcdir)/index.cache.bz2; then \ + echo $(INSTALL_DATA) $(srcdir)/index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/; \ + $(INSTALL_DATA) $(srcdir)/index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/; \ + fi + -rm -f $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/common + $(LN_S) $(kde_libs_htmldir)/$(KDE_LANG)/common $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/common + +uninstall-docs: + -rm -rf $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate + +clean-docs: + -rm -f index.cache.bz2 + + +#>+ 13 +install-nls: + $(mkinstalldirs) $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate + @for base in regular-expressions.docbook man-kate.1.docbook part.docbook mdi.docbook index.docbook menus.docbook advanced.docbook fundamentals.docbook configuring.docbook plugins.docbook highlighting.docbook ; do \ + echo $(INSTALL_DATA) $$base $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/$$base ;\ + $(INSTALL_DATA) $(srcdir)/$$base $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/$$base ;\ + done + +uninstall-nls: + for base in regular-expressions.docbook man-kate.1.docbook part.docbook mdi.docbook index.docbook menus.docbook advanced.docbook fundamentals.docbook configuring.docbook plugins.docbook highlighting.docbook ; do \ + rm -f $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/kate/$$base ;\ + done + + +#>+ 5 +distdir-nls: + for file in regular-expressions.docbook man-kate.1.docbook part.docbook mdi.docbook index.docbook menus.docbook advanced.docbook fundamentals.docbook configuring.docbook plugins.docbook highlighting.docbook ; do \ + cp $(srcdir)/$$file $(distdir); \ + done + +#>+ 15 +force-reedit: + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/tdebase/kate/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/tdebase/kate/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/tdebase/kate/Makefile.in + + +#>+ 21 +clean-bcheck: + rm -f *.bchecktest.cc *.bchecktest.cc.class a.out + +bcheck: bcheck-recursive + +bcheck-am: + @for i in ; do \ + if test $(srcdir)/$$i -nt $$i.bchecktest.cc; then \ + echo "int main() {return 0;}" > $$i.bchecktest.cc ; \ + echo "#include \"$$i\"" >> $$i.bchecktest.cc ; \ + echo "$$i"; \ + if ! $(CXX) $(DEFS) -I. -I$(srcdir) -I$(top_builddir) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(KDE_CXXFLAGS) --dump-class-hierarchy -c $$i.bchecktest.cc; then \ + rm -f $$i.bchecktest.cc; exit 1; \ + fi ; \ + echo "" >> $$i.bchecktest.cc.class; \ + perl $(top_srcdir)/admin/bcheck.pl $$i.bchecktest.cc.class || { rm -f $$i.bchecktest.cc; exit 1; }; \ + rm -f a.out; \ + fi ; \ + done + + +#>+ 3 +final: + $(MAKE) all-am + +#>+ 3 +final-install: + $(MAKE) install-am + +#>+ 3 +no-final: + $(MAKE) all-am + +#>+ 3 +no-final-install: + $(MAKE) install-am + +#>+ 3 +kde-rpo-clean: + -rm -f *.rpo + +#>+ 3 +nmcheck: +nmcheck-am: nmcheck diff --git a/tde-i18n-it/docs/tdebase/kate/advanced.docbook b/tde-i18n-it/docs/tdebase/kate/advanced.docbook new file mode 100644 index 00000000000..e18f2f87914 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/advanced.docbook @@ -0,0 +1,2336 @@ + + + +&Anders.Lund; &Anders.Lund.mail; +&Dominik.Haumann; &Dominik.Haumann.mail; +Nicola Ruggero
nicola@nxnt.org
Traduzione della documentazione.LucianoMontanaro
mikelima@cirulla.net
Aggiornamento per Kate 2.5.6 + + +Strumenti avanzati di modifica + + + +Commenta/Decommenta + +I comandi Commenta e Decommenta, disponibili nel menu Strumenti permettono di aggiungere o rimuovere indicatori di commento alla selezione, o alla riga attuale del testo se non hai selezionato niente, a patto che i commenti facciano parte del formato di testo del documento. + +Le regole su come è applicato il commento sono definite in base alla sintassi del testo che stai scrivendo, quindi se non hai selezionato una modalità di evidenziazione, non potrai usare Commenta/Decommenta. + +Alcuni formati usano indicatori di commento per righe singole, altri usano indicatori per più righe consecutive di commento ed altri ancora entrambi i sistemi. Se i marcatori multiriga non sono disponibili, commentare una selezione che non comprenda completamente la'ultima riga non è possibile. + +Se sono disponibili i marcatori per righe singole è preferibile usarli ogni volta che è possibile, perché ciò evita i problemi dei commenti nidificati. + +Quando rimuovi gli indicatori di commento devi fare attenzione a non selezionare testo che non fa parte del commento. Quando rimuovi i commenti su più righe da una selezione, gli spazi vuoti al di fuori degli indicatori di commento sono ignorati. + +commentare Per inserire gli indicatori di commento, usa il comando StrumentiCommenta oppure la relativa scorciatoria da tastiera, quella predefinita è &Ctrl;#. + +decommentare Per rimuovere gli indicatori di commento, usa il comando StrumentiDecommenta oppure la relativa scorciatoia da tastiera; quella predefinita è &Ctrl;&Shift;#. + + + + +La riga di comando per il componente dell'editor + +Il componente dell'editor di &kate; ha una riga di comando interna che permette di effettuare varie azioni da una GUI minima. La riga di comando è una casella di testo nella parte inferiore dell'area di modifica, per mostrarla seleziona VisualizzaPassa alla riga di comando o usa la scorciatoia (F7). L'editor fornisce l'insieme di comandi documentati di seguito, e comandi aggiuntivi sono forniti con i plugin. + +Per eseguire un comando, scrivilo e premi il tasto Invio. La riga di comando indicherà se ha avuto successo ed eventualmente mostrerà un messaggio. Se hai attivato la riga di comando premendo F7, verrà nascosta automaticamente dopo qualche secondo. Per pulire la riga ed inserire un nuovo comando, premi di nuovo F7. + +La riga di comando ha un sistema di aiuto integrato, usa il comando help per iniziare. Per vedere un elenco di tutti i comandi disponibili usa help list, per vedere l'aiuto di un comando specifico usa help comando. + +La riga di comando si ricorda la cronologia dei comandi, per cui puoi riutilizzare i comandi che hai già inserito. Per scorrere la cronologia, usa i tasti Freccia su e Freccia giù. Quando vengono mostrati i comandi della cronologia, la parte degli argomenti del comando è selezionata, in modo da permetterti di sovrascrivere semplicemente gli argomenti. + + +I comandi standard della riga di comando + + +Comandi per la configurazione dell'editor + +Questi comandi sono forniti dal componente dell'editor e permettono di configurare solo il documento attivo e la vista. Sono utili se vuoi usare impostazioni diverse da quelle predefinite, ad esempio per i rientri. + + +Tipi di argomento + + +BOOLEAN +Questo tipo è usato nei comandi che devono attivare o disattivare una caratteristica. I valori ammessi sono on, off, true, false, 1 o 0 + + + +INTEGER +Un numero intero + + + +STRING +Una stringa + + + + + + + +set-tab-widthINTEGER ampiezza +Imposta l'ampiezza della tabulazione al numero ampiezza. + + + +set-indent-widthINTEGER ampiezza +Imposta l'ampiezza dell'indentazione al numero ampiezza. È usata solo se stai indentando con gli spazi. + + + +set-word-wrap-columnINTEGER ampiezza +Imposta l'ampiezza della riga al numero ampiezza. È usata se il testo deve andare a capo automaticamente. + + + +set-icon-borderBOOLEAN abilitazione +Imposta la visibilità del bordo per le icone. + + + +set-folding-markersBOOLEAN abilitazione +Imposta la visibilità del pannello per gli indicatori di raggruppamento. + + + +set-line-numbersBOOLEAN abilitazione +Imposta la visibilità del pannello per i numeri di riga. + + + +set-replace-tabsBOOLEAN abilitazione +Se è abilitata, le tabulazioni sono sostituiti con spazi durante l'inserimento. + + + +set-remove-trailing-spaceBOOLEAN abilitazione +Se è abilitata, gli spazi in fin di riga vengono rimossi quando il cursore lascia una riga. + + + +set-show-tabsBOOLEAN abilitazione +Se è abilitata, i caratteri Tab e gli spazi bianchi in fin di riga saranno evidenziati con dei puntini. + + + +set-indent-spacesBOOLEAN abilitazione +Se è abilitata, l'editor farà rientrare il testo di spazi ad ogni livello di rientro, invece che di un carattere di tabulazione. + + + +set-mixed-indentBOOLEAN abilitazione +Se abilitazione vale true, kate userà una miscela di Tab e spazi per i rientri delle righe. Ciascun livello di rientro sarà largo , e più livelli di rientro saranno ottimizzati usando il maggior numero possibile di caratteri Tab. +Quando viene eseguito, questo comando inoltre abilita i rientri con gli spazi, e se l'ampiezza dei rientri non è specificata, sarà impostata alla metà di del documento al momento dell'esecuzione. + + + +set-word-wrapBOOLEAN abilitazione +Abilita o disabilita l'a capo automatico dinamico a seconda del parametro abilitazione. + + + +set-replace-tabs-saveBOOLEAN abilitazione +Quando è attiva questa opzione, le tabulazioni verranno sostituite con spazi durante il salvataggio del documento. + + + +set-remove-trailing-space-saveBOOLEAN abilitazione +Quando è attiva questa opzione, gli spazi alla fine delle righe saranno scartati durante il salvataggio del documento. + + + +set-indent-modenome +Imposta la modalità di autoindentazione a nome. Se nome è sconosciuto, la modalità sarà impostata a "none". Le modalità valide sono 'cstyle', 'csands', 'xml', 'python', 'varindent' e 'none'. + + + +set-highlightevidenziazione +Seleziona il sistema di evidenziazione della sintassi per il documento. L'argomento deve essere un nome di evidenziazione valido, così come è mostrato nel menu StrumentiEvidenziazione. Questo comando fornisce una lista per l'autocompletamento dell'argomento. + + + + + + + +Comandi per la modifica + +Questi comandi servono a modificare il documento corrente. + + + +indent +Fa rientrare le righe selezionate o la riga attuale. + + + +unindent +Elimina un passo di rientro delle righe selezionate o della riga attuale. + + + +cleanindent +Riordina l'indentazione delle righe selezionate o della riga attuale secondo le impostazioni per l'indentazione del documento. + + + +comment +Inserisce indicatori di commento per rendere la selezione o le righe selezionate o la riga attuale un commento secondo il formato di testo così com'è definito dalle regole di evidenziazione della sintassi del documento. + + + +uncomment +Rimuove gli indicatori di commento dalla selezione o dalle righe selezionate o dalla riga attuale secondo il formato di testo così com'è definito dalle regole di evidenziazione della sintassi del documento. + + + +kill-line +Elimina la riga attuale. + + + +replacemodellosostituzione +Sostituisce il testo corrispondente a modello con sostituzione. Se vuoi includere spazi bianchi nel modello, devi mettere le virgolette single o doppie attorno sia al modello, sia alla sostituzione. Se gli argomenti non sono tra virgolette,la prima parola è usata come modello ed il resto come sostituzione. Se la sostituzione è vuota, vengono rimosse le corrispondenze con il modello. +Puoi impostare dei modificatori per configurare la ricerca aggiungendo un due punti, seguiti da una o più lettere rappresentanti la configurazione, data nella forma replace:opzioni modello sostituzione. Le opzioni disponibili sono: + + +b +Cerca all'indietro. + + + +c +Cerca dalla posizione del cursore. + + + +e +Cerca solo all'interno della selezione. + + + +r +Esegue la ricerca con un'espressione regolare. Se è impostata, puoi usare \N, dove N è un numero che rappresenta le catture nella stringa di sostituzione. + + + +s +Esegue la ricerca facendo distinzione fra maiuscole e minuscole. + + + +p +Chiede il permesso prima di effettuare la sostituzione. + + + +w +Fa in modo che la ricerca consideri solo parole intere. + + + + + + + + + +dateformato +Inserisce la stringa dell'ora/data come è specificato in formato, o nel formato yyyy-MM-dd hh:mm:ss se non ne è specificato nessuno. Le seguenti traduzioni sono effettuate nell'interpretazione di formato: +dIl giorno in forma numerica senza zeri iniziali (1–31). +ddIl giorno in forma numerica con uno zero iniziale di allineamento (01–31). +dddIl nome del giorno abbreviato in forma locale (cioè "lun" ... "dom"). +ddddIl nome del giorno completo in forma locale (cioè "lunedì" ... "domenica"). +MIl mese in forma numerica senza zeri iniziali (1–12). +MMIl mese in forma numerica con uno zero iniziale se necessario (01–12). +MMMIl nome del mese abbreviato in forma locale (cioè "gen" ... "dic"). +yyLe ultime due cifre dell'anno (00–99). +yyyyL'anno come numero di quattro cifre (1752–8000). +hL'ora senza zero iniziali (0–23 o 1–12 se in modalità AM/PM). +hhL'ora con zero iniziali (00–23 o 01–12 se in modalità AM/PM). +mI minuti senza zero iniziali (0–59). +mmI minuti con zero iniziali (00–59). +sI secondi senza zero iniziali (0–59). +ssI secondi con zero iniziali (00–59). +zI millisecondi senza zeri iniziali (0–999). +zzzI millisecondi con zeri iniziali (000–999). +APUsa modalità AM/PM. AP sarà sostituito da "AM" per le ore antimeridiane o "PM" per quelle pomeridiane. +apUsa modalità am/pm. ap sarà sostituito da "am" per le ore antimeridiane o "pm" per quelle pomeridiane. + + + + + + + + + +charidentificatore + +Questo comando permette di inserire caratteri indicando il loro identificativo numerico, in decimale, ottale o esadecimale. Per usarlo apri la finestra di dialogo Comando di modifica e digita char: [numero] nel campo di inserimento, quindi fai clic su OK. + + +Esempi con il comando <command +>char</command +> + +Inserisci: char:234 +Ottieni: ê +Inserisci: char:0x1234 +Ottieni: ሴ + + + + + + + +sostituisci, come in sed +cerca, come in sed +s///[ig] %s///[ig] + + +Questo comando fa una ricerca/sostituzione nella riga di testo corrente o in tutto il file (%s///) in maniera del tutto simile a sed. + +In breve, la ricerca viene effettuata in base a un modello di ricerca, a una espressione regolare compresa tra la prima e la seconda barra. Quando viene trovata una corrispondenza, la parte che corrisponde viene sostituita con l'espressione compresa tra la seconda e la terza barra. Le parentesi nel modello di ricerca creano dei riferimenti all'indietro, vale a dire che il comando ricorda quali parti della stringa di ricerca tra parentesi hanno trovato corrispondenza; queste stringhe possono essere riutilizzate per sostituire pattern riferiti a \1 per il primo gruppo di parentesi, \2 per il secondo e così via. + +Per cercare precisamente il simbolo di parentesi ( o ), devi evitare il problema usando la barra rovescia in questo modo: \(\) + +Se metti una i alla fine dell'espressione, la corrispondenza avverrà senza tener far distinzione fra maiuscole o minuscole. Se metti una g, verranno sostituite tutte le corrispondenze del modello, altrimenti verrà sostituita solo la prima. + + + +Sostituire del testo nella riga corrente + +Il tuo caro vecchio compilatore ha appena finito di bloccarsi dicendoti che la classe myClass che compare nella riga 3902 del tuo file sorgente non è definita. + +"Naturale!" pensi, sai benissimo che si scrive MyClass. Vai alla riga 3902 e, invece di provare a cercare la parola nel testo, apri la finestra di dialogo Comando di modifica, inserisci s/myclass/MyClass/i, premi OK, salvi il file e lo compili – con successo senza errori. + + + + +Sostituire del testo nell'intero file + +Immagina di avere un file, nel quale nomini Miss Jensen parecchie volte e arriva qualcuno che ti dice che si è appena sposata con Mr Jones. Naturalmente tu vuoi sostituire tutti i Miss Jensen con Ms Jones. + +Lancia la finestra di dialogo Comando di modifica, digita nell'apposito campo %s/Miss Jensen/Ms Jones/ e premi invio. Il gioco è fatto! + + + + +Un esempio più avanzato + +Questo esempio usa i riferimenti all'indietro e le classi di carattere (se non sai che cosa sono, leggi la relativa documentazione citata più in basso). + +Immagina di avere la seguente riga: void MyClass::DoStringOps( String &foo, String &bar String *p, int &a, int &b ) + +Ora ti rendi conto che il codice non va bene e decidi di usare la parola chiave const per tutti gli argomenti reference, quelli caratterizzati dall'operatore & posto davanti al nome dell'argomento. Inoltre vorresti semplificare lo spazio vuoto in modo che ci sia solo uno spazio tra ogni parola. + +Apri la finestra di dialogo Comando di modifica e inserisci: s/\s+(\w+)\s+(&)/ const \1 \2/g e premi il pulsante OK. La g che si trova alla fine dell'espressione fa in modo che si ricompili un'espressione regolare, per ogni corrispondenza, da essere poi salvata come riferimento all'indietro. + +Ottieni: void MyClass::DoStringOps( const String &foo, const String &bar String *p, const int &a, const int &b ) + +Missione compiuta! Ora cos'è successo? Abbiamo cercato alcuni spazi vuoti (\s+) seguiti da alcuni caratteri alfabetici (\w+), seguiti da altri spazi vuoti (\s+), seguiti da una e commerciale e la porzione alfabetica con la e commerciale salvati nel processo per essere usati nell'operazione di sostituzione. Quindi abbiamo sostituito la parte corrispondente della nostra riga con uno spazio vuoto seguito da const, seguito da un altro spazio vuoto, seguito dalla porzione alfabetica (\1), seguito da uno spazio vuoto e infine seguito dalla e commerciale salvata (\2) + +Ora, in alcuni casi la porzione alfabetica era una String. in altri int, quindi se usi \w e il quantificatore + sarà meglio. + + + + + + + + + + + + +Comandi per gli spostamenti + + + + +gotoINT riga +Questo comando sposta il cursore alla riga indicata. + + + +findmodello +Questo comando si sposta alla prima corrispondenza del modello secondo la configurazione. Le corrispondenze successive possono essere trovate usando ModificaTrova successivo (la scorciatoia predefinita è F3). +Il comando find può essere configurato aggiungendo in fondo un due punti seguito da una o più opzioni, nella forma find:opzioni modello. Le seguenti opzioni sono disponibili: + + +b +Cerca all'indietro. + + + +c +Cerca dalla posizione del cursore. + + + +e +Cerca solo all'interno della selezione. + + + +r +Esegue la ricerca con un'espressione regolare. Se è impostata, puoi usare \N, dove N è un numero che rappresenta le catture nella stringa di sostituzione. + + + +s +Esegue la ricerca facendo distinzione fra maiuscole e minuscole. + + + +w +Fa in modo che la ricerca consideri solo parole intere. + + + + + + + + + + + +ifindmodello +Questo comando fornisce la ricerca mentre scrivi. Puoi configurarne il comportamento aggiungendo in fondo un due punti seguito da una o più opzioni, nella forma ifind:opzioni modello. Le seguenti opzioni sono disponibili: + +b +Cerca all'indietro. + + + +r +Esegue la ricerca di un'espressione regolare. + + + +s +Esegue la ricerca facendo distinzione fra maiuscole e minuscole. + + + +c +Cerca dalla posizione del cursore. + + + + + + + + + + + + + + + +Uso del raggruppamento del codice + +Il raggruppamento del codice permette di nascondere parti del documento nell'editor, rendendo più facile una panoramica di documenti di grandi dimensioni. In &kate; le regioni raggruppabili sono classificate usando le regole delle definizioni dell'evidenziazione della sintassi, e quindi sono disponibili solo in alcuni formati — tipicamente codice sorgente, annotazioni XML e simili. La maggior parte delle definizioni di evidenziazione che permettono il raggruppamento del codice permettono anche la definizione manuale di regioni raggruppabili, tipicamente con l'uso delle parole chiave BEGIN ed END. + +Per usare la funzione di raggruppamento del codice, attiva gli indicatori di raggruppamento usando la voce VisualizzaMostra segni di raggruppamento del menu se non sono già visibili. Il pannello degli indicatori di raggruppamento sul lato sinistro dello schermo mostra una vista grafica delle regioni raggruppabili, con segni +/- indicanti l'operazione possibile su una data regione: Un - indica che la regione è espansa, facendo clic sul - ridurrà la regione ad una sola riga, mentre un + la mostrerà completamente. + +Sono forniti quattro comandi per manipolare lo stato delle regioni di raggruppamento del codice, vedi la documentazione del menu. + +Se non vuoi usare la funzione di raggruppamento del codice, puoi disabilitare l'opzione Mostra segni di raggruppamento (se disponibile) dalla pagina Aspetto delle configurazioni dell'editor. + + + + + +Scripting del componente dell editor con JavaScript + + + +Introduzione + +Dalla versione 2.5, il componente dell'editor di &kate; gestisce gli script con ECMAScript, noto anche come JavaScript. + +Gli script possono essere usati con la sola riga di comando integrata. I requisiti sono che lo script sia messo in una cartella dove &kate; possa trovarlo, assieme al file .desktop opzionale che ne definisce le proprietà associate. Le cartelle valide sono chiamate katepart/scripts nelle cartelle dei dati di &kde;. Puoi trovare le cartelle dei dati scrivendo kde-config data Normalmente c'è almeno una cartella dei dati di sistema ed una personale. Naturalmente gli script nella cartella dei dati di sistema sono utilizzabili da tutti gli utenti, mentre quelli nella cartella personale lo possono essere usati solo da te. + +Questa funzione è sperimentale e probabilmente cambierà durante gli sviluppi futuri. +Sappiamo che molti di voi saranno delusi perché non è possibile aggiungere script al menu o assegnarvi scorciatoie da tastiera. Molto probabilmente sarà possibile in futuro. +Inoltre non è ancora possibile passare degli argomenti agli script. Sii paziente, e anche questo potrebbe essere aggiunto in futuro! + + + + + + +L'API JavaScript di Kate + +Ecco elencata la raccolta completa di funzioni e proprietà disponibili per gli oggetti document e view. Inoltre sono disponibili naturalmente gli oggetti standard, come Math, String, Regexp e così via. + +Quando viene eseguito uno script, l'oggetto document è il documento attuale, e l'oggetto view è la vista corrente. + +I tipi degli argomenti ovviamente non sono usati da JavaScript, al momento. Servono solo ad indicare qhe tipo di valori le funzioni si aspettino. + + +Funzioni globali + +debug( stringa) [funzione] + + +parametri +stringa il messaggio da stampare + + +Stampa la stringa su STDERR usando la funzione kdDebug(). Un'area di output dedicata è usata per l'output, che sarà preceduto da Kate (KJS Scripts):. + + + + + +L'API di <classname +>document</classname +> + + +document.attribute( riga , colonna ); [funzione] + + +Parametri +uint riga La riga della posizione per cui trovare l'attributo. +uint colonna La colonna della posizione per cui trovare l'attributo. + +Restituisce l'ID numerico dell'attributo per la posizione del documento 0riga, colonna]. L'attributo rappresenta l'aspetto o lo stile del testo, ed è anche usato per calcolare l'evidenziazione della sintassi per una parte specifica del testo in formati misti come l'HTML e il PHP. + + + + +document.canBreakAt( Char c, uint attributo ); [funzione] + + +Parametri +c Il carattere da verificare +attributo L'attributo alla posizione di c. + +Restituisce true se è permesso interrompere la riga al carattere c con l'attributo dato. Il risultato è determinato dall'interrogazione dell'evidenziazione che possiede l'attributo per sapere quali caratteri permettono l'interruzione della riga. + + + + +document.canComment( uint attributo_inizio, uint attributo_fine ); [funzione] + + +Parametri +attributo_inizio L'attributo dell'inizio dell'intervallo da tramutare in commento. +attributo_fine L'attributo della fine dell'intervallo da tramutare in commento. + +Controlla se attributo_inizio e attributo_fine appartengono allo stesso sistema di evidenziazione della sintassi. Se è così, va tutto bene. + +Uso di canComment +if ( document.canComment( document.attribute(1,0), document.attribute(5,0) ) ) { + // 1,0 e 5,0 appartengono allo stesso sistema di evidenziazione di sintassi +} + + + + + + +document.clear(); [funzione] +Svuota il documento. + + + +document.commentStart( uint attributo ); [funzione] + + +Parametri +attributo L'attributo del testo di cui ottenere la stringa di indicazione di inizio commento (commentStart). + +Restituisce la stringa richiesta per avviare un commento su più righe per il testo con l'attributo dato, o una stringa vuota se i commenti su più righe non sono disponibili per quel tipo di testo. + + + + +document.commentMarker( uint attributo ); [funzione] + + +Parametri +attributo L'attributo del testo di cui ottenere la stringa di indicazione commento (commentMarker). + +Restituisce la stringa usata per indicare che il resto della riga è un commento per un testo con l'attributo dato o una stringa vuota se i commenti su riga singola non sono disponibili per il testo dato. + + + + +document.commentEnd( uint attributo ); [funzione] + + +Parametri +attributo L'attributo del testo di cui ottenere la stringa di indicazione di fine commento (commentEnd). + +Restituisce la stringa richiesta per terminare un commento su più righe per il testo con l'attributo dato, o una stringa vuota se i commenti su più righe non sono disponibili per quel tipo di testo. + + + + +document.editBegin(); [funzione] + +Inizia un gruppo di modifiche. Tutte le azioni eseguite fino alla chiamata di editEnd() saranno raggruppate in una sola azione di annullamento. + + + + +document.editEnd(); [funzione] + +Termina un gruppo di modifiche. + + + + +document.highlightMode; [proprietà:sola lettura] + +IL nome dellla modalità di evidenziazione del documento, come JavaScript o C++. Se non è impostata nessuna modalità di evidenziazione per il documento, il valore è None. Nota che è necessario usare il nome inglese nei casi in cui sia diverso da quello tradotto. + + + + +document.indentMode; [proprietà:sola lettura] + +Il nome della modalità di indentazione del documento, come normal o cstyle. Ricorda che se non è impostata una modalità di indentazione, il valore è none. + + + + +document.indentWidth; [proprietà:sola lettura] + +L'ampiezza del rientro impostata per il dcumento. È usata se è attiva l'indentazione con gli spazi. + + + + +document.insertLine( uint riga, string testo ); [funzione] + + +Parametri +riga numero della riga del documento + +testo testo da inserire + +Inserisce una nuova riga di testo testo alla riga riga. + + + + +document.insertText( uint riga, uint colonna, string testo ); [funzione] + + +Parametri +riga numero della riga +colonna il numero della colonna +testo il testo da inserire + +Inserisce il testo testo alla riga riga e alla colonna colonna. + + + + +document.length(); [funzione] + +Restituisce la dimensione del documento in byte. + + + + +document.lines(); [funzione] + +Restituisce il numero di righe del documento. + + + + +document.mixedIndent; [proprietà:sola lettura] + +Un valore booleano che indica se la modalità mixed-indent è abilitata per il documento. Se è così, l'indentazione è ottimizzata per contenere una miscela di caratteri di tabulazione e spazi come fa l'editor Emacs. + + + + +document.removeLine( uint numeroriga ); [funzione] + + +Parametri +riga numero di riga + +Rimuove la riga numeroriga dal documento. + + + + +document.removeText( uint rigaIniziale, uint colonnaIniziale, uint rigaFinale, uint colonnaFinale ); [funzione] + + +Parametri +rigaIniziale indica la riga d'inizio +colonnaIniziale indica la colonna d'inizio +rigaFinale indica la riga di fine +colonnaFinale indica la colonna di fine + +Rimuove la sezione di testo che inizia da riga rigaIniziale e colonna colonnaIniziale fino a rigaFinale e colonna colonnaFinale. + + + + +document.setText( string testo ); [funzione] + + +Parametri +testo testo del documento + +Sostituisce il testo dell'intero documento con testo. + + + + +document.spaceIndent; [proprietà:sola lettura] + +Un valore booleano che indica se è abilitata l'indentazione con gli spazi per il documento. Se è così, il documento è indentato con indentWidth spazi per livello, altrimenti è di una tabulazione per livello. + + + + +document.textFull(); [funzione] + +Restituisce il testo completo del documento. Se il testo continua su più righe il carattere di separazione delle righe è \n. + + + + +document.textLine( uint numeroRiga ); [funzione] + + +Parametri +numeroRiga il numero della riga + +Restituisce il testo della riga numeroRiga. + + + + +document.textRange( uint rigaIniziale, uint colonnaIniziale, uint rigaFinale, uint colonnaFinale ); [funzione] + + +Parametri +rigaIniziale indica la riga d'inizio +colonnaIniziale indica la colonna d'inizio +rigaFinale indica la riga di fine + +colonnaFinale indica la colonna di fine + +Restituisce il testo dell'intervallo selezionato. Se il testo continua su più righe il carattere di separazione delle righe è \n. + + + + + + +L'API di <classname +>view</classname +> + + +view.clearSelection(); [funzione] + +Deseleziona tutto il testo. + + + + +view.cursorColumn(); [funzione] + +Restituisce la colonna su cui si trova il cursore (i caratteri di tabulazione sono espansi). + + + + +view.cursorColumnReal(); [funzione] + +Restituisce la colonna su cui si trova il cursore (i caratteri di tabulazione contano come uno). + + + + +view.cursorLine(); [funzione] + +Restituisce il numero di riga attuale del cursore. + + + + +view.hasSelection(); [funzione] + +Restituisce true se la vista contiene del testo selezionato, altrimenti false. + + + + +view.removeSelectedText(); [funzione] + +Elimina il testo selezionato, se c'è una selezione nella vista. + + + + +view.selectAll(); [funzione] + +Seleziona tutto il testo. + + + + +view.selection(); [funzione] + +Restituisce il testo selezionato. Se la selezione è composta da più righe, il carattere di separazione delle righe è \n. + + + + +view.selectionEndColumn; [proprietà:sola lettura] + +Restituisce il numero di colonna della fine della selezione. + + + + +view.selectionEndLine; [proprietà:sola lettura] + +Restituisce il numero di riga della fine della selezione. + + + + +view.selectionStartColumn; [proprietà:sola lettura] + +Restituisce la colonna iniziale della selezione. + + + + +view.selectionStartLine; [proprietà:sola lettura] + +Restituisce la riga iniziale della selezione. + + + + +view.setCursorPosition( uint riga, uint colonna ); [funzione] + + +Parametri +riga Specifica la riga del cursore. +colonna Specifica la colonna del cursore. + +Sposta la posizione del cursore nella vista a [riga, colonna]. La posizione del cursore è calcolata in modo visuale, cioè i caratteri di tabulazione contano per tabwidth spazi, a seconda della posizione all'interno della riga. La posizione del cursore è resa visibile. Sia la riga che la colonna sono contate partendo da zero. + + + + +view.setCursorPositionReal( uint riga, uint colonna ); [funzione] + + +Parametri +riga Specifica la riga del cursore. +colonna Specifica la colonna del cursore. + +Sposta la posizione del cursore nella vista a [riga, colonna]. Questa funzione imposta la posizione nella stringa di caratterim cioè un carattere di tabulazione conta per uno. Sia la riga che la colonna sono contate partendo da zero. + + + + +view.setSelection( uint rigaIniziale, uint colonnaIniziale, uint rigaFinale, uint colonnaFinale ); [funzione] + + +Parametri +rigaIniziale indica la riga d'inizio +colonnaIniziale indica la colonna d'inizio +rigaFinale indica la riga di fine +colonnaFinale indica la colonna di fine + +Seleziona il testo da riga rigaIniziale e colonna colonnaIniziale fino a riga rigaFinale e colonna colonnaFinale. + + + + + + + +Uno script di esempio +Come esempio, prepareremo un breve script che rende maiuscole tutte le lettere della selezione. È ovvio che dovremo prima controllare se esiste una selezione, quindi ottenere il testo, rendere ogni lettera maiuscola ed infine sostituire il vecchio testo col nuovo. Un'implementazione potrebbe essere questa: + +if ( view.hasSelection() ) +{ + // uppercase selection + column = view.selectionStartColumn; + line = view.selectionStartLine; + + selection = view.selection().toUpperCase(); + + document.editBegin(); + view.removeSelectedText(); + document.insertText( line, column, selection ); + document.editEnd(); +} + + +Per raggruppare queste azioni assieme i modo che siano annullate con una singola attivazione di Annulla, incapsuliamo le righe view.removeSelectedText() e document.insertText() con un document.editBegin() ed un document.editEnd(). + + + + +Un esempio di file <filename +>.desktop</filename +> + +Ecco un esempio di file .desktop da associare allo script summenzionato. + +# Example of a .desktop file +[Desktop Entry] +Encoding=UTF-8 +Name=Kate Part JavaScript Uppercase +Comment=Script to uppercase the selection +X-Kate-Command=uppercase-selection +X-Kate-Help=<p>Usage: <code>uppercase-selection</code></p> + + +Come puoi vedere è possibile definire la codifica, il nome, un commento, un testo di aiuto usando X-Kate-Help ed il nome per la riga di comando usando X-Kate-Command. Le voci Name, Comment e X-Kate-Help sono tradotte automaticamente in altre lingue dalle squadre di traduzione di KDE, se i file risiedono nel deposito SVN di KDE. + + + + +Mettere tutto assieme + +&kate; cercherà i file *.js nelle cartelle degli script (vedi sopra). Per ciascun file controlla se è presente un file .desktop; ad esempio, per uppercase.js cercherebbe un file uppercase.desktop. +Se un file .desktop non è presente, lo script sarà registrato nella riga di comando di KatePart con il nome del file senza l'estensione .js, quindi nell'esempio, questo vuol dire uppercase. Se il nome del comando va bene e non ti servono le altre caratteristiche fornite dai file .desktop, non è affatto necessario creare il file. +Se esiste un file .desktop, KatePart leggerà il nome sotto cui lo script sarà registrato dalla voce X-Kate-Command del file .desktop, ad esempio X-Kate-Command=uppercase-selection. + + + + + + + + diff --git a/tde-i18n-it/docs/tdebase/kate/configuring.docbook b/tde-i18n-it/docs/tdebase/kate/configuring.docbook new file mode 100644 index 00000000000..cc6e89744cf --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/configuring.docbook @@ -0,0 +1,2606 @@ + + + +&Anders.Lund; &Anders.Lund.mail; +Nicola Ruggero
nicola@nxnt.org
Traduzione della documentazione.LucianoMontanaro
mikelima@cirulla.net
Aggiornamento della traduzione per &kate; 2.5.6 + + +Configurare &kate; + + +Panoramica + + +configura +impostazioni +preferenze + &kate; offre parecchi mezzi per adattare l'applicazione alle proprie esigenze. I più importanti sono: + + + +La finestra di dialogo della Configurazione +Lo strumento principale di configurazione ti permette di configurare l'applicazione &kate;, i componenti dell'editor e l'uso dei plugin. + + +Il menu Impostazioni +Ti permette di cambiare le impostazioni usate più spesso e ti permette di aprire la finestra di dialogo della configurazione. + + +Il menu Visualizza +Ti permette di dividere la finestra in cui lavori, visualizzare le icone e visualizzare il pannello con la numerazione di riga per documento che stai modificando. + + + +La &konsole; integrata sta usando la configurazione definita nel &kcontrolcenter;, e può essere riconfigurata facendo clic con il pulsante destro del mouse e scegliendo Impostazioni dal sotto menu. + + + + +La finestra principale di configurazione + + + + + + + +La finestra di dialogo di &kate; mostra un menu ad albero, con varie voci sulla sinistra e a destra la pagina di configurazione corrispondente alla voce di destra. + +La configurazione è divisa in due gruppi, rispettivamente +Configurazione dell'applicazione + +Configurazione della componente dell'editor + + + + + + + + +La configurazione dell'applicazione &kate; +Questo gruppo contiene le pagine per configurare l'applicazione principale di &kate; + + +La pagina Generale +Questa sezione contiene alcune opzioni globali di &kate; + + + + + +Mostra l'intero percorso nel titolo +Se è abilitata, Kate mostrerà l'URL completo del documento attuale nell titolo della finestra, invece del solo nome. + + + + + +Comportamento + + + + + +Sincronizza l'emulatore di terminale con il documento attivo +Questa opzione farà in modo che la &konsole; integrata cambi directory con il comando cd in modo tale da posizionarsi nella stessa directory del documento attivo. Questa opzione ha effetto sia all'apertura di un documento sia quando un nuovo documento va in primo piano. Se l'opzione non è attivata, devi cambiare directory manualmente nella &konsole;. + + + + +Avverti se un file è modificato da un processo estraneo +Se questa opzione è abilitata, &kate; ti avvertirà se dei file sono stati modificati al di fuori dell'applicazione quando la finestra principale è focalizzata. Potrai dover gestire più file modificati contemporaneamente, e potrai scegliere se ricaricare, salvare o scartare i file modificati in gruppi. +Se non è abilitata, &kate; chiederà che cosa fare quando un file modificato dall'esterno riceve il fuoco nell'applicazione. + + + + + + + + + +Dati aggiuntivi + + + + + +Ricorda le meta-informazioni +Se questa opzione è abilitata &kate; memorizzerà i metadati come i segnalibri e la configurazione della sessione anche quando chiudi i documenti. I dati saranno usati se il documento non è stato cambiato prima di essere riaperto. + + + + +Elimina meta informazioni inutilizzate dopo +Imposta il massimo numero di giorni per cui conservare le meta-informazioni per i file non aperti. Ciò permette di mantenere la base dati delle meta-informazioni entro dimensioni ragionevoli. + + + + + + + + + + + +La pagina Sessioni + +Questa sezione contiene opzioni relative all'uso delle sessioni. + + + + + +Elementi delle sessioni + + + +Includi la configurazione della finestra +Se questa opzione è abilitata, &kate; salverà la configurazione della finestra con ogni sessione. + + + + + + + +Comportamento all'avvio dell'applicazione + +Seleziona il comportamento di &kate; all'avvio. Questa impostazione può essere annullata specificando che cosa fare dalla riga di comando. + + +Avvia nuova sessione +Con questa opzione, &kate; creerà una nuova sessione senza nome all'avvio. + + +Carica l'ultima sessione utilizzata +&kate; userà la sessione usata più di recente all'avvio. È comodo se vuoi usare sempre la stessa sessione o se la cambi raramente. + + +Scegli a mano una sessione +&kate; mostrerà una finestrella per la scelta della sessione preferita. Questo è il comportamento predefinito. Comodo se usi molte sessioni diverse di frequente. + + + + + + + +Comportamento all'uscita dell'applicazione o al cambio di sessione + + + +Non salvare la sessione +e modifiche ai dati della sessione (i file aperti, e, se abilitata, la configurazione delle finestre) non saranno salvate. Naturalmente verrai interpellato se hai dei file non salvati. Con questa opzione, puoi configurare la sessione una volta ed evitare di dover chiudere i file extra che ha aperto per non vederli aperti al successivo uso della sessione. + + +Salva sessione +&kate; salverà i dati di sessione, a meno che la sessione sia senza nome. Con questa opzione, le sessioni sono sempre ripristinate come le hai lasciate. Questo è il comportamento predefinito. + + +Chiedi all'utente +Ti verrà chiesto se vuoi salvare la sessione ogni volta che una sessione che ha un nome viene chiusa. + + + + + + + + + + +La pagina <guilabel +>Selettore dei file</guilabel +> + + + +Barra degli strumenti +Configura i pulsanti della barra del gestore dei file spostando quelli desiderati sulla lista Azioni attuali, ed ordinali usando i pulsanti con le frecce a lato della lista. + + + + +Sincronizzazione automatica +Puoi fare in modo che il navigatore del filesystem si posizioni automaticamente sulla directory contenente il documento attuale in caso di eventi particolari: Quando un documento diventa quello attivo. Quando il browser del filesystem diventa visibile. Anche se scegli di non usare questa funzione, puoi sincronizzare a mano il navigatore con il documento attuale premendo il pulsante Sincronizza della barra degli strumenti. + + + +Ricorda gli indirizzi +Scegli quanto deve essere lunga la cronologia della navigazione. Il navigatore ricorda solo i percorsi individuali, i duplicati sono esclusi. + + + +Ricorda i filtri +Scegli quanti filtri vuoi che siano ricordati. Vengono ricordati solo i filtri individuali, i duplicati sono esclusi. + + + +Sessione + +Configura se il navigatore del file system debba ricordare le posizioni ed i filtri da una sessione all'altra. + + + + + + + + +La pagina <guilabel +>Lista documenti</guilabel +> + + + +Sfumature sfondo +Questa sezione permette di abilitare e disabilitare la visualizzazione dell'ombreggiatura dello sfondo delle tue attività recenti, e di scegliere quali colori usare se la abiliti. Vedi la sezione La lista dei documenti per maggiori informazioni su questa funzione. + + +Ordina per +Imposta il tipo di ordinamento da dare ai documenti. Può anche essere cambiato con il menu del &RMB; dalla lista dei documenti. + + + + + + +La pagina <guilabel +>Plugin</guilabel +> + +Questa pagina fornisce un elenco dei plugin installati in &kate;. Ciascun plugin è rappresentato con il nome ed una breve descrizione. Puoi marcare la casella di una voce per abilitare il plugin che rappresenta. + +Se un plugin fornisce opzioni di configurazione apparirà una sezione per l'accesso ad esse. + + + + + +Strumenti esterni + +Nel menu Strumenti c'è un sottomenu chiamato Strumenti esterni. Questi strumenti invocano applicazioni esterne con i dati correlati al documento esterno, ad esempio il suo URL, la directory, il testo o la selezione. Questa pagina permette di gestire il menu e modificare, eliminare o aggiungere nuovi strumenti. + +Ciascuno strumento esterno è un comando di shell che contiene delle macro rappresentanti i dati del documento. Quando viene attivato, le macro vengono sostituite dai dati del documento attivo. + + +Proprietà degli strumenti esterni + +Etichetta +Un'etichetta amichevole per il menu degli strumenti esterni. + + + +Script +Lo script da eseguire quando viene attivato lo strumento. Prima di passare lo script alla shell, vengono sostituite le seguenti macro: + +%URL +L'URL completo del documento attuale, o una stringa vuota se il documento non è stato salvato. + + + +%URLS +Una lista separata da spazi degli URL dei documenti aperti (esclusi quelli non salvati). + + + +%directory +La parte della directory dell'URL del documento attuale, o una stringa vuota se il documento attuale non è stato salvato. + + + +%filename +il nome del file del documento corrente senza il percorso, o una stringa vuota se il documento corrente non è mai stato salvato. + + + +%line +Il numero di riga del cursore di inserimento nel documento attuale. + + + +%column +Il numero della colonna del cursore di inserimento nel documento attuale. + + + +%selection +Il testo selezionato nel documento attuale, o una stringa vuota se non c'è testo selezionato + + + +%text +Il testo completo del documento attuale. Fai attenzione, perché potrebbe eccedere la lunghezza massima della riga di comando permessa sul tuo sistema. Da usare con prudenza. + + + + + + + + +Eseguibile +L'eseguibile principale è lo script. Questo è obbligatorio, ed è usato per provare se il comando può essere eseguito. UN percorso completamente qualificato è ammesso nel caso in cui l'eseguibile non sia fra i percorsi della variabile PATH. + + + +Tipi MIME +Una lista separata de punti e virgola dei tipi MIME per cui questo comando debba essere abilitato. Attualmente non è usata. + + + +Salva +Puoi scegliere di far salvare il documento corrente o tutti prima di eseguire lo script, se lo desideri. Ciò è utile se il tuo script legge il file da disco. + + + +Nome da riga di comando +Se compili questo campo, lo strumenti sarà disponibile dalla riga di comando dell'editor come exttool-Nome da riga di comando (la stringa che hai immesso qui, preceduta da exttool-). + + + + + + + + + +Configurazione del componente dell'editor +Questo gruppo contiene tutte le pagine collegate con il componente dell'editor di &kate;. Quasi tutte le impostazioni sono quelle predefinite, che vengono sovrascritte dalla definizione di un tipo di file, dalle variabili dei documenti o cambiandole nel documento durante la sessione di modifica. + + + +Aspetto + + + +A capo automatico + + + +A capo automatico dinamico +Se quest'opzione è marcata, le righe proseguiranno a capo quando raggiungeranno il bordo della finestra. + + +Indicatori a capo automatico dinamico +Scegli se gli indicatori di andata a capo automatico dinamico debbano essere visualizzati. + +Allinea verticalmente le righe andate a capo dinamicamente alla profondità di indentazione: +Abilita l'inizio di una riga andata a capo dinamicamente allineato verticalmente con il livello di indentazione della prima riga. Ciò può aiutare a rendere il codice e la formattazione più leggibile.Inoltre permette di impostare la massima larghezza dello schermo come percentuale, dopo la quale le righe andate a capo dinamicamente non saranno più allineate verticalmente. Ad esempio, a 50%, le righe il cui livello di indentazione è più profondo del 50% della larghezza dello schermo non avranno allineamento verticale applicato alle seguenti righe andate a capo automaticamente. + + + + + + +Raggruppamento codice + + + +Mostra gli indicatori di raggruppamento +Se questa opzione è attivata, la vista corrente mostrerà degli indicatori per il raggruppamento del codice, se il raggruppamento del codice è disponibile. + + + + + + +Bordi + + + +Mostra bordo per le icone +Se attivata, vedrai un bordo per le icone sul lato sinistro. Il bordo per le icone mostra, ad esempio, i marcatori dei segnalibri. + + +Mostra numeri di riga +Se attivata, vedrai i numeri di riga sul lato sinistro. + + +Mostra i segni nella barra di scorrimento +Se questa opzione è attivata la vista attuale mostrerà indicatori sulla barra di scorrimento verticale. Questi segni possono mostrare, ad esempio, i segnalibri. + + + + + + +Ordina il menu dei segnalibri + + + +Per posizione +I segnalibri saranno ordinati a seconda dei numeri di riga a cui sono collocati. + + +Per creazione +Ogni nuovo segnalibro verrà aggiunto in coda, indipendentemente da dove è collocato nel documento. + + + + + + +Mostra righe di indentazione +Se attivato, l'editor mostrerà delle righe verticali per favorire l'identificazione delle righe indentate. + + + + + +Caratteri e colori + +Questo sezione della finestra permette di configurare tutti i caratteri e i colori in qualsiasi schema di colori tu abbia, oltre a creare nuovi schemi o eliminare quelli esistenti. Ciascuno schema ha impostazioni per i colori, i tipi di carattere e per gli stili del testo normale ed evidenziato. + +&kate; preselezionerà lo schema attualmente attivo, se vuoi lavorare su uno schema diverso inizia selezionandolo dalla casella combinata Schema. + + +Colori + + + +Sfondo area del testo + + + + + +Testo normale +Questo è lo sfondo predefinito per l'area dell'editor, sarà il colore dominante dell'area principale. + + + +Testo selezionato +Il colore di sfondo del testo selezionato. Il valore predefinito è il colore globale della selezione, così come è configurato dalle preferenze dei colori di &kde;. + + + +Riga corrente +Imposta il colore della riga corrente. Se è un po' diverso da quello del testo normale, permette di tenere a fuoco la riga. + + + +Segnalibro +Questa casella permette di scegliere i colori da sovrapporre per i vari tipi di indicatori. Il colore è miscelato con quello di sfondo della riga indicata, in modo che le righe con più indicatori o una riga indicata che è quella corrente ha uno sfondo che è una miscela di più colori. I colori degli indicatori sono anche usati se abiliti la visualizzazione degli indicatori nella barra di scorrimento. + + + + + + + +Elementi aggiuntivi + + + +Sfondo bordo sinistro +Questo colore è usato per gli indicatori, i bordi per i numeri di riga e per gli indicatori di raggruppamento sul lato sinistro della vista dell'editor, quando sono mostrati. + + +Numeri di riga +Questo colore è usato per disegnare i numeri di riga sul lato sinistro della vista, quando sono mostrati. + + +Evidenziazione parentesi +Questo colore è usato per lo sfondo delle parentesi corrispondenti. + + +Indicatori a capo automatico +Questo colore è usato per disegnare un motivo sulla sinistra delle righe fatte andare a capo automaticamente quando vengono allineate verticalmente, ed anche per l'indicatore di a capo statico. + + +Marcatori di tabulazione +Questo colore è usato per gli indicatori di spazi bianchi, quando sono abilitati. + + + + + + + + + +Tipi di carattere +Qui puoi scegliere il tipo di carattere dello schema. Puoi scegliere fra tutti i tipi di carattere disponibili nel sistema, ed impostare la dimensione predefinita. Un testo di esempio è mostrato nella parte inferiore della finestra, per darti un'idea dell'effetto della tua scelta. + + + +Stili testo normale +Lo stile di testo normale è ereditato dagli stili di evidenziazione del testo; ciò permette all'editor di presentare il testo in modo coerente, ad esempio, il testo dei commenti è uguale in quasi tutti i formati di testo che &kate; può evidenziare. +Il nome della lista di stili usa lo stile configurato per tale elemento, fornendoti un'anteprima quando configuri lo stile. +Ogni stile permette di selezionare degli attributi comuni oltre ai colori di sfondo e primo piano. Per rimuovere l'impostazione del colore di sfondo, fai clic con il tasto destro per usare il menu contestuale. + + + +Stili testo evidenziazione +Qui puoi modificare gli stili del testo usati per una specifica definizione di evidenziazione. L'editor preseleziona l'evidenziazione usata per il documento attuale. Per lavorare con un'evidenziazione diversa, selezionane una dalla casella combinata Evidenziazione sopra l'elenco di stili. +Il nome della lista di stili usa lo stile configurato per tale elemento, fornendoti un'anteprima quando configuri lo stile. +Ciascuno stile permette di selezionare attributi comuni oltre ai colori di sfondo e primo piano. Per eliminare il colore di sfondo, fai clic con il tasto destro per usare il menu contestuale. Inoltre puoi vedere se uno stile è uguale a quello predefinito dell'elemento, ed assegnarlo ad esso se non lo è. +Noterai che molte evidenziazioni contengono altre evidenziazioni rappresentate dai gruppi nell'elenco di stili. Ad esempio la maggior parte delle evidenziazioni importano l'evidenziazione Alert, e molte altre importano l'evidenziazione per Doxygen. La modifica dei colori di questi gruppi ha effetto solo sugli stili quando è usata nel formato di evidenziazione modificato. + + + + + +Cursore e selezione + + + + +Spostamento cursore testo + + + +Home e Fine intelligenti + +Se questa casella è marcata, la pressione del tasto Home farà saltare al cursore gli spazi bianchi e lo farà posizionare all'inizio del testo della riga. + + + +Cursore a capo + +Quando è attiva, l'uso dei tasti freccia a sinistra e freccia a destra sul cursore di inserimento ne causerà lo sposterà alla riga precedente/successiva all'inizio/fine della riga, come nella maggior parte degli editor.Quando non è attiva, il cursore di inserimento non può essere spostato a sinistra dell'inizio di una riga, ma può esserlo oltre la fine di una riga, funzione molto comoda per i programmatori. Quando questa opzione viene scelta, spostare il cursore con il tasto freccia destra oltre la fine di una riga (a destra) lo farà saltare all'inizio della successiva.Allo stesso modo quando il cursore è mosso indietro oltre l'inizio di una riga (a sinistra) salterà alla fine della riga precedente. Quando questa opzione non è selezionata, spostare il cursore a destra dopo la fine della riga, lo farà soltanto continuare orizzontalmente sulla stessa riga e cercare di muoverlo a sinistra dell'inizio della riga non farà nulla. + + + +PaginaSu/PaginaGiù sposta il cursore + +Questa opzione cambia il comportamento del cursore quando l'utente preme il tasto PaginaSu o il tasto PaginaGiù. Se non è selezionato il cursore del testo manterrà la sua posizione relativamente al testo visibile in &kate;, quando del nuovo testo diventerà visibile come risultato dell'operazione. Così se il cursore è al centro del testo visibile, quando avviene l'operazione, rimarrà lì (eccetto quando si raggiunge l'inizio o la fine). Quando questa opzione è selezionata, il primo tasto premuto causerà lo spostamento del cursore alla cima o alla base del testo visibile non appena si visualizza una nuova pagina di testo. + + + +Centramento automatico cursore (righe): + +Imposta il numero di righe che, se possibile, devono rimanere visibili sopra e sotto il cursore. + + + + + + + +Modalità di selezione + + + +Normale + +Le selezioni vengono sovrascritte con il testo digitato e vanno perse quando si muove il cursore. + + + +Permanente + +Le selezioni rimangono anche dopo lo spostamento del cursore e l'inserimento di testo. + + + + + + + + + + +Modifica + + + +Tabulazioni + + + +Inserisci spazi invece delle tabulazioni + +Quando questa opzione è abilitata, l'editor inserirà un numero appropriato di spazi a seconda della posizione del testo e dell'ampiezza delle tabulazioni () quando premi il tasto Tab. + + + +Mostra le tabulazioni + +Quando questa voce è abilitata, &kate; mostra un puntino come rappresentazione visibile di un carattere di tabulazione. +Mostra anche dei puntini per gli spazi bianchi in fondo alle riga. Ciò verrà corretto in una futura versione di &kate; + + + +Larghezza tabulazioni Se l'opzione Inserisci spazi invece delle tabulazioni è selezionata questa casella determina il numero di spazi con cui l'editor sostituirà le tabulazioni. + + + + + + +A capo automatico statico +L'a capo automatico è una funzionalità che fa iniziare automaticamente all'editor una nuova riga di testo e sposta il cursore all'inizio di quella nuova riga. &kate; comincerà automaticamente una nuova riga di testo quando la riga corrente raggiungerà la lunghezza specificata dall'opzione Colonna a cui andare a capo. + + +Abilita a capo automatico statico + +Attiva o disattiva l'a capo automatico statico. + + + +Mostra indicatori a capo automatico statico (se possibile) + +Se questa opzione è selezionata, verrà disegnata una barra verticale sulla colonna di andata a capo definita in Impostazioni Configura editor... nella scheda Modifica. Nota che l'indicatore di andata a capo sarà disegnato solo se utilizzi un font a spaziatura fissa. + + + +Colonna a cui andare a capo: + +Se l'opzione A capo automatico è selezionata questa casella determina la lunghezza (in caratteri) arrivata alla quale l'editor comincerà automaticamente una nuova riga. + + + + + + + +Rimuovi gli spazi finali +&kate; eliminerà automaticamente gli spazi extra alla fine delle righe di testo. + + +Parentesi automatiche Quando l'utente scrive una parentesi aperta ([, ( o {) &kate; inserisce automaticamente la parentesi chiusa corrispondente (}, ) o ]) alla destra del cursore. + + + Massimo numero diannullamenti: +Qui l'utente può specificare il numero di azioni che &kate; terrà in memoria allo scopo di azioni di annulla. Ciò significa che più alto è il numero di azioni, più memoria &kate; userà per questo. Impostare questa voce a 10 significherebbe che l'utente sarebbe in grado di revocare le ultime dieci operazioni, cioè facendo clic 10 volte sul pulsante di annulla e ottenendo i risultati. + + Fonte del testo da cercare: +Questa opzione determina la fonte da cui &kate; prenderà il testo da cercare, cioè il testo inserito automaticamente nella finestra Trova testo: Nessuna: non indovinare il testo da cercare. Solo la selezione: usa il testo attualmente selezionato, se possibile. La selezione, poi la parola attuale: usa la selezione attuale se possibile, altrimenti usa la parola attuale. Solo la parola attuale: usa la parola su cui si trova il cursore, se possibile. La parola attuale, poi la selezione: usa la parola attuale se possibile, altrimenti usa la selezione attuale. Nota che, in tutte le modalità indicate, se non è possibile determinare una stringa di ricerca allora verrà usato l'ultimo testo cercato. + + + + + +Indentazione + + +Indentazione automatica + + + +Modalità di indentazione: + +Seleziona la modalità di indentazione automatica che vuoi utilizzare come predefinita. Si raccomanda caldamente di impostare Nessuno o Normale e di utilizzare le configurazioni specifiche per tipo di file per impostare altre modalità di indentazione per formati di testo come codice C/C++ o &XML;. + + + +Inserisci un "*" iniziale per Doxygen durante la scrittura + +Inserisce automaticamente un "*" quando si scrive un commento in stile Doxygen. Questa impostazione è abilitata solo quando si applica alla situazione. + + + + + + + +Indentazione con spazi + + + +Usa gli spazi invece delle tabulazioni per indentare + +Questo sostituisce le tabulazioni con il numero di spazi impostato in Numero di spazi: più sotto. + + + +Modalità mista stile Emacs + +Usa una miscela di tabulazioni e caratteri di spazio per l'indentazione. + + + +Numero di spazi: + +Imposta il numero di spazi da usare per l'indentazione per l'opzione Usa gli spazi invece delle tabulazioni. + + + + + + + +Conserva il profilo di indentazione +Quando questa opzione è abilitata,l'editor non eliminerà ulteriormente l'indentazione dalle righe selezionate quando essa viene annullata dalla riga con indentazione minima. Se talvolta togli l'indentazione da blocchi di codice dove essa è presente, questa opzione può essere utile. + + + +Conserva gli spazi extra +Le indentazioni maggiori del numero di spazi selezionato non saranno accorciate. + + + +Tasti da usare + + + +Il tasto Tab indenta + +Permette di usare il tasto Tab per indentare. + + + +Il tasto Backspace indenta + +Permette di usare il tasto Backspace per indentare. + + + + + + + +Modalità tasto Tab in caso di assenza di selezione + + + +Inserisci carattere di indentazione + +Permette che Tab inserisca caratteri di rientro. + + + +Inserisci carattere di tabulazione + +Permette che Tab inserisca caratteri di tabulazione. + + + +Indenta la riga attuale + +Permette che Tab indenti la riga attuale. + + + + + + + + + + +Apri/Salva + + + + +Formato file + + + +Codifica: + +Imposta la codifica predefinita dei tuoi file. + + + +Fine della riga: + +Sceglie la modalità di fine riga preferita per il documento attuale. Puoi scegliere tra &UNIX;, DOS/&Windows;o Macintosh. + + + +Rilevazione automatica fine riga + +Marca la casella se vuoi che l'editor riconosca automaticamente il tipo di fine riga. Il primo tipo di fine riga incontrato verrà usato per tutto il file. + + + + + + + +Uso della memoria + + + +Massimo blocchi caricati per file: + +L'editor caricherà in memoria il numero di blocchi di testo indicato (di circa 2048 righe); se la dimensione del file è più grande il resto dei blocchi saranno mantenuti sul disco e caricati in modo trasparente quando necessario. +Questo può causare brevi ritardi quando ci si sposta nel documento; un numero di blocchi più grande migliora la velocità in cambio di un maggior uso della memoria. Per un uso normale, scegli il numero di blocchi più alto possibile: metti un limite solo se hai problemi di uso della memoria. + + + + + + + +Pulizia automatica al salvataggio/caricamento + + + +Rimuovi gli spazi finali + +L'editor eliminerà automaticamente gli spazi in eccesso alla fine delle righe di testo durante il caricamento/salvataggio del file. + + + + + + + +Cartella file di configurazione + + + +Profondità di ricerca del file di configurazione: + +L'editor cercherà più in su nell'albero delle cartelle del numero di livelli indicato per trovare i file di configurazione di &kate; e caricare le impostazioni da esso. + + + + + + + +Copia di sicurezza al salvataggio +La copia di sicurezza al salvataggio fa copiare a &kate; il file su disco in "<prefisso><nomefile>suffisso<" prima di salvare le modifiche. Il suffisso predefinito è ~ ed il prefisso è vuoto. + + +File locali + +Marca la casella se vuoi una copia di sicurezza dei file locali quando salvi. + + + +File remoti + +Marca la casella se vuoi una copia di sicurezza dei file remoti quando salvi. + + + +Prefisso + +Inserisci il prefisso per i nomi delle copie di sicurezza. + + + +Suffisso + +Inserisci il suffisso per i nomi delle copie di sicurezza. + + + + + + + + + + + +Evidenziazione +Questo gruppo di opzioni è usato per personalizzare gli stili di evidenziazione per ogni tipo di linguaggio di programmazione. Qualsiasi cambiamento fatto in altre aree di questa finestra di dialogo si applica solamente a questo tipo. + + + +Evidenziazione: +È usata per scegliere il tipo di linguaggio da configurare. + + + +Informazioni + +Mostra le proprietà delle regole di evidenziazione del linguaggio scelto: nome dell'autore e licenza. + + + + +Proprietà + + + +Estensioni file: +Questa è la lista delle estensioni dei file usata per determinare quali file evidenziare con la modalità di evidenziazione della sintassi attuale. + + +Tipi MIME: +Facendo clic sul pulsante della procedura guidata apparirà una finestra con la lista dei tipi MIME disponibili da cui scegliere.Verrà modificata anche la voce Estensioni file. + + +Priorità: +Imposta la priorità della regola di evidenziazione. + + + + + + +Scarica... + +Fai clic su questo pulsante per scaricare descrizioni delle sintassi aggiornate dal sito Web di &kate;. + + + + + + + +Tipi di file +Questa pagina ti permette di modificare la configurazione predefinita per documenti aventi specifici tipi mime. Quando l'editor carica un documento, ne cerca la corrispondenza, tramite le maschere o i tipi mime, con un tipo di file conosciuto. Se viene trovata più di una corrispondenza verrà usata quella con la più alta priorità. + + +Tipo di file: +Il tipo di file con la priorità più alta è quello mostrato nella prima casella combinata. Se vengono trovati più tipi di file, verranno mostrati tutti. + + +Nuovo +Questo è usato per creare un nuovo tipo di file. Dopo aver fatto clic su questo pulsante, i campi sottostanti si svuotano e puoi riempire quelli appropriati per il nuovo tipo di file. + + +Elimina +Per eliminare un tipo di file esistente, selezionalo dalla casella combinata e premi il pulsante Elimina. + + + + + +Proprietà del tipo di file attuale +Il tipo di file con la priorità più alta è quello mostrato nella prima casella combinata. Se vengono trovati più tipi di file, verranno mostrati tutti. + + +Nome: +Il nome del tipo di file sarà il testo della corrispondente voce del menu. Questo nome è mostrato in StrumentiTipi di file + + +Sezione: +Il nome della sezione è usato per organizzare i tipi di file nei menu. Può essere anche usato nel menu Strumentitipi di file. + + +Variabili: +Questa stringa permette di configurare le impostazioni di &kate; per i file selezionati da questo tipo mime usando le variabili di &kate;. Puoi impostare quasi tutte le opzioni di configurazione, come l'evidenziazione, la modalità di indentazione, la codifica ecc.Per un elenco completo delle variabili vedi il manuale. + + +Estensioni file: +La maschera per i caratteri jolly permette di selezionare i file per nome. Una tipica maschera usa un asterisco e l'estensione del file, ad esempio *.txt; *.text. La stringa è un elenco di maschere separato da punti e virgola. + + +Tipi MIME: +Mostra una procedura guidata che ti consente di scegliere facilmente i tipi MIME. + + +Priorità: +Imposta una priorità per questo tipo di file. Se più di un tipo di file seleziona uno stesso file, verrà utilizzato il tipo di file con priorità più alta. + + + + + + + + +Scorciatoie +Puoi cambiare da qui la configurazione dei tasti scorciatoia. Seleziona un'azione e fai clic su Personalizzata se vuoi una scorciatoia diversa per questa azione. +La riga di ricerca permette di cercare un'azione specifica e vedere la scorciatoia associata. + + + +Plugin +Questa scheda elenca tutti i plugin disponibili; puoi marcare tutti quelli che vuoi usare. Una volta che hai marcato un plugin, il pulsante Configura è abilitato e puoi fare clic su di esso per configurare il plugin evidenziato. + + + + + + + + +Configurazione con le variabili del documento + +Le variabili di Kate rappresentano l'implementazione come componente KatePart delle variabili del documento, simili alle modeline di emacs e di vi. Nella componente KatePart le righe hanno la forma kate: NOMEVARIABILE VALORE; [ NOMEVARIABILE VALORE; ... ] le righe possono naturalmente essere in un commento, se il formato del file prevede i commenti. I nomi delle variabili sono costituiti da un'unica parola (senza spazi) ed ogni cosa fino al successivo punto e virgola è interpretato come valore. Il punto e virgola è necessario. + +Ecco un esempio di riga di variabili, che forza le regole di rientro per i file C++, Java o JavaScript: // kate: space-indent on; indent-width 4; mixedindent off; indent-mode cstyle; + + +Solo le prime e le ultime 10 righe di ogni file vengono controllate alla ricerca di righe di variabili. + +Ci sono variabili per gestire quasi tutte le configurazioni di un componente KatePart, e i plugin aggiuntivi possono usare le variabili, che in tal caso devono essere documentate nel manuale del plugin. + + +Come kate usa le variabili + +Quando legge la configurazione, la componente KatePart controlla nelle seguenti posizioni (nell'ordine): La configurazione globale. Valori opzionali di sessione. La configurazione "Tipi di file". Variabili del documento presenti nel documento stesso. Impostazioni modificate in fase di modifica da menu o da riga di comando. Come puoi ben capire le variabili del documento hanno la priorità più alta. Quando un documento viene salvato, le variabili corrispondenti verranno lette nuovamente e sovrascriveranno i cambiamenti fatti tramite voci di menu o riga di comando. + +Le variabili non elencate qui sotto possono essere inserite nel documento e possono essere utilizzate da altri oggetti come i plugin, che possono usarle per i propri scopi. Ad esempio la modalità di indentazione variabile usa le variabili del documento per la propria configurazione. + +Le variabili elencate qui documentano &kate; versione 2.4. Altre variabili potrebbero essere aggiunte in futuro. Ci sono tre possibili tipi di valori per le variabili, con le seguenti espressioni valide: +BOOL - on|off|true|false|1|0 +INTEGER - un numero intero +STRING - qualsiasi altra cosa + + + + +Variabili disponibili + + +auto-bracketsBOOL +Attiva o disattiva l'inserimento automatico delle parentesi. + + + +auto-center-linesINT +Imposta il numero di righe autocentranti. + + + +auto-insert-doxygenBOOL +Attiva o disattiva l'inserimento dell'asterisco iniziale nei commenti doxygen. Non ha effetto se non si usa l'indentazione automatica in stile C. + + + +background-colorSTRING +Imposta il colore di sfondo del documento. Il valore deve essere qualcosa che venga valutato come un colore valido, come "#ff0000". + + + +backspace-indentsBOOL +Abilita o disabilita l'indentazione alla pressione del tasto Backspace. + + + +block-selectionBOOL +Attiva o disattiva la selezione per blocchi. + + + +bracket-highlight-colorSTRING +Il colore per l'evidenziazione delle parentesi. Deve essere qualcosa che venga valutato come un colore valido, come "#ff0000" + + + +current-line-colorSTRING +Il colore della riga corrente. Il valore deve essere qualcosa che venga valutato come un colore valido, come "#ff0000". + + + +dynamic-word-wrapBOOL +Attiva o disattiva l'a capo automatico dinamico. + + + +eol | end-of-lineSTRING +Imposta la modalità di fine riga. Le impostazioni valide sono unix, mac e dos + + + +encodingSTRING +Imposta la codifica del documento. Il valore deve essere un nome di codifica valida, come utf-8. + + + +font-sizeINT +Imposta la dimensione in punti del tipo di carattere del documento. + + + +fontSTRING +Imposta il nome del tipo di carattere del documento. Il valore deve essere un tipo di carattere valido, per esempio courier. + + + +icon-bar-colorSTRING +Imposta il colore della barra per le icone. Il valore deve essere qualcosa che venga valutato come un colore valido, come #ff0000. + + + +icon-borderBOOL +Attiva o disattiva la visualizzazione del bordo per le icone. + + + +folding-markersBOOL +Attiva o disattiva la visualizzazione degli indicatori di raggruppamento. + + + +indent-modeSTRING +Imposta la modalità di indentazione automatica. Sono riconosciute le opzioni none, normal, cstyle, csands, python e xml. Vedi la sezione per i dettagli. + + + +indent-widthINT +Imposta l'ampiezza dell'indentazione. + + + +keep-extra-spacesBOOL +Imposta de devono essere tenuti gli spazi extra quando si calcolano le ampiezze dell'indentazione. + + + +keep-indent-profileBOOL +Se assegni TRUE a questa variabile, viene impedito la disindentazione di un blocco se almeno una riga non ha indentazione. + + + +line-numbersBOOL +Attiva o disattiva la visualizzazione del numero di riga. + + + +mixed-indentBOOL +Attiva o disattiva l'indetazione mista in stile Emacs. + + + +overwrite-modeBOOL +Attiva o disattiva la modalità sovrascrittura. + + + +persistent-selectionBOOL +Attiva o disattiva la selezione persistente. + + + +remove-trailing-spaceBOOL +Attiva o disattiva la ripulitura dinamica a fi di riga. + + + +replace-tabs-saveBOOL +Attiva o disattiva la conversione di tabulazioni in spazi in fase di salvataggio. + + + +replace-tabsBOOL +Attiva o disattiva la conversione dinamica di tabulazioni in spazi. + + + +replace-trailing-space-saveBOOL +Attiva o disattiva la ripulitura della fine della riga in fase di salvataggio. + + + +schemeSTRING +Imposta lo schema di colori. La stringa deve essere il nome di uno schema di colori che esiste nella tua configurazione perché abbia effetto. + + + +selection-colorSTRING +Imposta il colore della selezione. Il valore deve essere qualcosa che venga valutato come un colore valido, ad esempio "#ff0000#". + + + +show-tabsBOOL +Attiva o disattiva il carattere di tabulazione visibile. + + + +smart-homeBOOL +Attiva o disattiva la modalità di navigazione intelligente verso l'inizio della riga. + + + +space-indentBOOL +Attiva o disattiva l'indentazione con spazi. + + + +tab-indentsBOOL +Attiva o disattiva l'indentazione col tasto Tab. + + + +tab-widthINT +Imposta la larghezza a schermo della tabulazione. + + + +undo-stepsINT +Imposta il numero di passi di annullamento da ricordare. + + + +word-wrap-columnINT +Imposta l'ampiezza per l'a capo forzato. + + + +word-wrap-marker-colorSTRING +Imposta il colore per l'indicatore di a capo. Il valore deve essere qualcosa che venga valutato come un colore valido, come "#ff0000". + + + +word-wrapBOOL +Attiva o disattiva l'a capo forzato. + + + +wrap-cursorBOOL +Attiva o disattiva l'a capo automatico del cursore. + + + + + + + + + diff --git a/tde-i18n-it/docs/tdebase/kate/fundamentals.docbook b/tde-i18n-it/docs/tdebase/kate/fundamentals.docbook new file mode 100644 index 00000000000..2cf183f3311 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/fundamentals.docbook @@ -0,0 +1,1089 @@ + + + + +Nicola Ruggero
nicola@nxnt.org
Traduzione della documentazione. + + +I Fondamenti + +Se hai già usato un editor di testo, non avrai problemi usando &kate;. Nelle prossime due sezioni, Avvio di &kate; e Lavorare con &kate;, ti mostreremo tutto quello che devi sapere per iniziare ad usarlo velocemente. + + +Avvio di &kate; + +Puoi avviare &kate; dal menu K o dalla riga di comando. + + +Dal menu +Apri il menu dei programmi di &kde; facendo clic sulla grossa K nel pannello in fondo a sinistra del tuo schermo. Questo ti farà raggiungere il menu programmi. Muovi il tuo cursore verso la voce Accessori Editor. Apparirà una lista degli editor disponibili. Scegli &kate;. + +Finché non dici a &kate; di non farlo, caricherà l'ultimo file che hai modificato. Vedi Configurare &kate; per imparare come attivare o disattivare questa caratteristica. + + + + +Dalla riga di comando + +Puoi avviare &kate; digitando il nome dalla riga di comando. Se gli scrivi accanto anche il nome di un file, come nell'esempio qui sotto, ti apre o ti crea quel file. + + +%kate + + + +Se hai una connessione attiva, e i permessi, puoi approfittare del vantaggio della trasparenza nella rete di &kde; per aprire file in internet. + + +%kate + + + + +Opzioni dalla riga di comando +&kate; accetta le seguenti opzioni dalla riga di comando: + + + +kate + +Questo elenca le opzioni di base più comuni disponibili dalla riga di comando. + + + + +kate + +Questo elenca le opzioni disponibili per modificare il modo in cui &kate; interagisce con &Qt;. + + + + +kate + +Questo elenca le opzioni disponibili per modificare il modo in cui &kate; interagisce con &kde;. + + + + +kate nome + +Avvia kate con la sessione nome. La sessione è creata se non è già esistente. Se un'istanza di &kate; con la sessione specificata è già in esecuzione, i file specificati sono caricati in tale istanza. Quando è usata con l'opzione , verrà usata allo stesso modo un'istanza in esecuzione con questa sessione. + + + + +kate URL + +Fa usare a &kate; un'istanza già esistente se ne esiste una. Se vuoi aprire tutti i documenti in una sola istanza di &kate;, puoi aggiungere questa opzione al comando predefinito nella configurazione delle applicazioni di &kde;, e puoi creare un alias per la shell, se il tuo interprete di comandi la supporta. + + + + +kate PID + +Riutilizza un'istanza con il PID specifico (ID del processo) Usala con l'opzione . + + + + +kate codifica URL +Usa la codifica specificata per il documento. + + + +kate riga URL +Si posiziona alla riga specificata dopo aver aperto il documento. + + + +kate colonna URL +Si posiziona alla colonna specificata dopo aver aperto il documento. + + + +kate +Legge il contenuto del documento da STDIN. È simile all'opzione comunemente usata in molti programmi da riga di comando, e permette di incanalare l'output di un comando in &kate;. + + + +kate +Da &kate; 2.5.1 questa opzione standard di &kde; è supportata. Quando è usata, i file specificati sono trattati come file temporanei e cancellati (se sono locali ed hai i permessi appropriati) quando vengono chiusi, a meno che non siano modificati da quando sono stati aperti. + + + +kate + +Questo elenca tutte le opzioni disponibili dalla riga di comando. + + + + +kate + +Elenca gli autori di &kate; nella finestra del terminale. + + + + +kate + +Elenca le informazioni sulla versione di &Qt;, &kde; e &kate;. + + + + +kate + +Mostra le informazioni sulla licenza. + + + + + + + +Trascinamento +&kate; usa il protocollo di trascinamento (drag and drop protocol) di &kde;. I file possono essere trascinati e rilasciati in &kate; dal Desktop, &konqueror; o da alcuni siti ftp aperti in più finestre di &konqueror;. + + + + +Lavorare con &kate; +Avvio rapido ti mostrerà come modificare quattro semplici opzioni che ti consentiranno di configurare alcune della più potenti caratteristiche di &kate;. Scorciatoie visualizza alcune delle scorciatoie predefinite per le quali non è possibile o desiderabile usare il mouse. + + +Avvio rapido + +Questa sezione descrive alcuni degli elementi presenti nel menu Impostazioni in modo che tu possa configurare rapidamente &kate; per lavorare nella maniera che desideri. + +Avviando &kate; per la prima volta vedrai due finestre con lo sfondo bianco. Sopra le due finestre c'è una barra degli strumenti con le solite icone etichettate. E sopra a questa, la barra dei menu. + +La finestra di sinistra è una barra laterale. Combina le finestre dei Documenti dei file e del Selettore dei file. Cambia da una finestra all'altra facendo clic sulle linguette a sinistra. + +Se hai avviato &kate; con un file, la finestra a destra mostrerà il file che stai modificando ed il pannello Documenti nella barra laterale mostrerà il nome del file. Usa la finestra del Selettore dei file per aprire i file. + +Puoi attivare o disattivare il pannello dei Documenti o del Selettore file dal menu FinestreViste accessorie. Questo menu offre una prima occhiata alle potenzialità e alla flessibilità di &kate;. In questa sezione tratteremo tre elementi: + + + + + + +Mostra/Nascondi documenti + + + +Attiva o disattiva i Documenti. Se la finestra Documenti/Selettore file non è aperta, &kate; apre la barra laterale come una finestra separata e non agganciata. Per agganciare la finestra afferra le due sottili linee parallele sopra le linguette facendo clic su esse con il &LMB; e mantenendo premuto il pulsante. Trascina la finestra nella finestra dell'editor di &kate; e rilascia il &LMB; quando hai posizionato la finestra Documenti/Selettore file dove preferisci. + + +Se hai afferrato con successo le due linee parallele il tuo puntatore del mouse si trasformerà in due frecce incrociate fin tanto che trascini. + + + + + +Mostra nascondi Browser del filesystem + +Attiva o disattiva il Selettore file. Questo elemento del menu è lo stesso di Mostra Documenti con una differenza. Attivandolo apri la finestra con i Documenti in primo piano. + + + + +Mostra/Nascondi terminale + +Attiva o disattiva la visualizzazione dell'emulatore di terminale nella parte bassa della finestra di &kate;. In altre parole, ti fornisce una riga di comando integrata nell'applicazione. + + + + + + +Scorciatoie + +Molte scorciatoie di &kate; possono essere configurate attraverso il menu Impostazioni. Le impostazioni predefinite di &kate; prevedono le seguenti associazioni di tasti. + + + + + +inserisci +Cambia tra la modalità Inserisci e Sovrascrivi. Quando sei nella modalità Inserisci l'editor aggiunge al testo i caratteri digitati e spinge il testo già presente a sinistra del cursore. La modalità Sovrascrivi fa in modo che l'inserimento di ogni carattere elimini il carattere immediatamente a destra del cursore. + + +Freccia sinistra +Muove il cursore un carattere a sinistra + + +Freccia destra +Muove il cursore un carattere a destra + + +Freccia su +Muove il cursore su di una riga + + +Freccia giù +Muove il cursore giù di una riga + + +Pagina su +Muove il cursore su di una pagina + + +Pagina giù +Muove il cursore giù di una pagina + + +Backspace +Cancella il carattere a sinistra del cursore + + +Home +Muove il cursore all'inizio della riga + + +Fine +Muove il cursore alla fine della riga + + +Canc +Cancella il carattere a destra del cursore (o qualsiasi testo selezionato) + + +&Shift;Freccia sinistra +Seleziona il testo un carattere a sinistra + + +&Shift;Freccia destra +Seleziona il testo un carattere a destra + + +F1 +Aiuto + + +&Shift;F1 +Che cos'è? + + +&Ctrl;F +Trova + + +F3 +Trova ancora + + +&Ctrl;B +Imposta un segnalibro + + +&Ctrl;C +Copia il testo selezionato negli appunti. + + + +&Ctrl;N +Nuovo documento + + +&Ctrl;P +Stampa + + + +&Ctrl;Q +Esci - chiude la copia attiva dell'editor + + +&Ctrl;R +Sostituisci + + +&Ctrl;S +Salva il file. + + +&Ctrl;V +Incolla. + + + +&Ctrl;X +Cancella il testo selezionato e lo copia negli appunti. + + +&Ctrl;Z +Annulla + + +&Ctrl;&Shift;Z +Rifai + + + + + + + + + +Uso delle sessioni + +Le sessioni sono il metodo che &kate; usa per raccogliere liste multiple di file e di configurazioni. Puoi avere tante sessioni con nome quante ne vuoi, e puoi usare le sessioni senza nome o anonime per i file che vuoi usare solo una volta. Attualmente &kate; può salvare la lista dei file aperti e la configurazione generale della finestra in una sessione; versioni future di &kate; potrebbero aggiungere altre caratteristiche memorizzabili nelle sessioni. Con l'introduzione delle sessioni, &kate; permette anche di aprire un numero a piacere di istanze dell'applicazione invece di una sola, come faceva normalmente prima. + +Le sessioni sono utilizzate in tre aree: +Le opzioni da riga di comando che permettono di selezionare ed avviare sessioni quando si avvia kate dalla riga di comando. + +Il menu Sessioni che permette di cambiare, salvare e gestire le sessioni. +Le opzioni di configurazione che permettono di decidere come debbano comportarsi generalmente le sessioni. + + + + +Quando si avvia una nuova sessione viene caricata la configurazione della GUI della Sessione predefinita. Per salvare la configurazione della finestra come sessione predefinita, devi abilitare il salvataggio della configurazione della finestra nella pagina di configurazione delle sessioni della finestra di configurazione e poi caricare la sessione predefinita, impostare la finestra come preferisci e salvare nuovamente la sessione. + +Quando viene caricata una sessione nominata, &kate; mostra il nome della sessione all'inizio del titolo, che quindi avrà la forma "Nome sessione: Nome o &URL; del documento - &kate;" + +Aprendo i file da riga di comando con o se selezioni una sessione dal selettore delle sessioni, la sessione specificata è caricata prima dei file specificati dalla riga di comando. Per aprire file dalla riga di comando in una sessione nuova e senza nome, configura kate per avviare una nuova sessione in modo predefinito dalla pagina delle sessioni della finestra di configurazione oppure usa l'opzione con una stringa vuota: ''. + +Da &kate; 2.5.1 il PID dell'istanza attuale è esportato alla variabile di ambiente KATE_PID. Quando vengono aperti dei file dal terminale integrato Kate selezionerà automaticamente l'istanza attuale se non viene indicato nient'altro sulla riga di comando. + + +Ripristinare il comportamento delle vecchie versioni di &kate; + +Quando ti sarai abituato all'uso delle sessioni, speriamo che tu le trovi un metodo semplice ed efficiente per lavorare in vari campi. Però se preferisci il vecchio comportamento di &kate; (un'istanza apre tutti i file), puoi facilmente ottenerlo seguendo questa semplice strategia: +Fai in modo che &kate; sia avviato sempre con il parametro , aggiungendo l'opzione al comando fra le preferenze dell'applicazione, e aggiungendo un alias per la shell. +Configura &kate; per caricare l'ultima sessione usata all'avvio. + +Configura &kate; per salvare l'elenco dei file quando viene chiusa una sessione. +Carica la sessione predefinita una volta + + + + + + + + + +Ricevere aiuto + + + +Con &kate; + + + +Questo manuale + + +Offre una documentazione dettagliata su tutti i comandi dei menu, opzioni di configurazione, strumenti, finestre di dialogo, plugin &etc; così come le descrizioni delle finestre di &kate;, l'editor e i vari concetti usati nell'applicazione. + +Premi F1 o usa il menu Aiuto Manuale di Kate per visualizzare questo manuale. + + + + +Guida a Che cos'è? + +Che cos'è? offre un aiuto immediato con i singoli elementi delle finestre grafiche, come i pulsanti o altre aree della finestra. + +Noi ci sforziamo di fornire l'aiuto Che cos'è? a tutti gli elementi per cui ha senso che esista. È disponibile nella finestra di dialogo della configurazione e in molte altre finestre di dialogo. + +Per usare l'aiuto Che cos'è?, premi &Shift;F1 oppure usa il menu AiutoChe cos'è? per abilitare la modalità Che cos'è?. In questo caso il cursore si trasformerà in una freccia con un punto di domanda. Ora puoi fare clic su qualsiasi elemento della finestra e leggere l'aiuto Che cos'è? per quell'elemento (se disponibile). + + + + +Pulsanti di aiuto nelle finestre di dialogo + +Alcune finestre di dialogo possiedono il pulsante Aiuto. Se lo premi aprirai il centro di &khelpcenter; e quindi la documentazione collegata. + + + + + + + +Con i tuoi file di testo + +&kate; non fornisce (non ancora!) tutti gli strumenti per leggere la documentazione relativa ai documenti. A seconda del file che stai modificando, puoi trovare utile la &konsole; integrata per vedere le pagine del manuale di &UNIX; o la documentazione di info, oppure puoi usare &konqueror;. + + + + + + diff --git a/tde-i18n-it/docs/tdebase/kate/highlighting.docbook b/tde-i18n-it/docs/tdebase/kate/highlighting.docbook new file mode 100644 index 00000000000..9ef12ca9233 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/highlighting.docbook @@ -0,0 +1,1380 @@ + + + + +LucianoMontanaro
mikelima@cirulla.net
Traduzione + + +Lavorare con l'evidenziazione della sintassi + + + +Panoramica + +L'evidenziazione della sintassi è ciò che rende l'editor capace di mostrare il testo in diversi stili e colori, a seconda della funzione delle stringhe per il tipo di file in fase di modifica. Nei sorgenti dei programmi, ad esempio, le istruzioni di controllo potrebbero essere rese in grassetto, mentre i tipi di dato ed i commenti potrebbero essere colorati diversamente dal resto del testo. Ciò migliora molto la leggibilità del testo, e quindi aiuta l'autore ad essere più efficiente e produttivo. + + + +Una funzione Perl, mostrata con l'evidenziazione della sintassi. +Una funzione Perl, mostrata con l'evidenziazione della sintassi. + + + + + +La stessa funzione Perl, senza l'evidenziazione. +La stessa funzione Perl, senza l'evidenziazione. + + +Dei due esempi, qual è la più facile da leggere? + +&kate; ha un sistema flessibile, configurabile e capace per eseguire l'evidenziazione della sintassi, e la distribuzione standard fornisce le definizioni per un'ampia gamma di linguaggi di programmazione, di script, di annotazione e per altri formati di file testuali. In più, puoi fornire le tue definizioni in semplici file &XML;. + +&kate; riconosce automaticamente le regole di sintassi appropriate quando apre un file, in base al suo tipo &MIME;, determinato dall'estensione, o se non ne ha, dal contenuto. Se facesse una scelta sbagliata, puoi indicare a mano la sintassi da usare dal menu StrumentiEvidenziazione. + +Gli stile e colori usati da ciascuna definizione di evidenziazione della sintassi possono essere configurati usando la pagina Aspetto della finestra di configurazione, mentre i tipi &MIME; per cui va usato sono gestiti dalla pagina di Evidenziazione. + + +L'evidenziazione della sintassi è fatta per migliorare la leggibilità di testo corretto, ma non puoi affidarti ad essa per la convalida del testo. Analizzare il testo per riconoscerne la sintassi è un compito difficile, per alcuni formati, e in qualche caso gli autori delle regole di riconoscimento sono orgogliosi quando riescono a rendere correttamente il 98% del testo, sebbene molto spesso devi usare uno stile molto raro per vedere il 2% scorretto. + + + +Puoi scaricare definizioni per l'evidenziazione della sintassi aggiornate o aggiuntive dal sito Web di &kate;, facendo clic sul pulsante Scarica dalla pagina Evidenziazione della finestra di configurazione. + + + + + + +Il sistema di evidenziazione della sintassi di &kate; + +Questa sezione tratta del meccanismo di evidenziazione della sintassi di &kate; in maggior dettaglio. È per chi voglia saperne di più o per chi voglia creare o modificare le definizioni della sintassi. + + + +Come funziona + +Quando apri un file, una delle prime attività svolte da &kate; è l'identificazione della definizione della sintassi da usare per tale file. Leggendo il testo del file, o quando tu lo immetti, il sistema di evidenziazione analizza il testo usando le regole definite dalle definizioni della sintassi e si segna dove i diversi contesti e stili iniziano e finiscono. + +Quando scrivi nel documento, il nuovo testo è analizzato e catalogato al volo, quindi de elimini un carattere che è indicato come l'inizio o la fine di un contesto, lo stile del testo adiacente cambierà di conseguenza. + +Le definizioni delle sintassi usate dal sistema di evidenziazione della sintassi di &kate; sono file &XML; contenenti +Regole per identificare il ruolo del testo, organizzato in blocchi contestuali +Elenco delle parole chiave +Definizione degli elementi di stile + + + +Quando viene analizzato il testo, le regole di identificazione sono valutate nell'ordine in cui sono definite, e se l'inizio della stringa attuale corrisponde ad una regola, il contesto correlato viene usato. Il punto iniziale del testo è spostato al punto finale in cui la regola corrisponde, e viene eseguito un nuovo ciclo sulle regole, iniziando nel contesto della regola applicata. + + + + +Regole + +Le regole di identificazione sono il cuore del sistema di evidenziazione. Una regola è una stringa, un carattere o una espressione regolare da confrontare con il testo da analizzare. Contiene informazioni su quale stile usare per la parte del testo a cui corrisponde. Può cambiare il contesto di lavoro del sistema o ad un contesto esplicitamente menzionato o al precedente contesto usato dal testo. + +Le regole sono organizzate in gruppi di contesti. Un gruppo di contesti è usato per i concetti principali del testo all'interno del formato, ad esempio stringhe di caratteri virgolettate o blocchi di commento nei sorgenti di programma. Ciò assicura che il sistema di evidenziazione non debba controllare tutte le regole quando non è necessario, e che alcune sequenze di caratteri possano essere trattate in modo diverso a seconda del contesto attuale. + +I contesti possono essere generati dinamicamente per permettere l'uso di dati specifici per le istanze nelle regole. + + + + +Stili del contesto e parole chiave + +In alcuni linguaggi di programmazione i numeri interi sono trattati dal compilatore (il programma che converte il codice sorgente in eseguibile binario) in modo diverso dai numeri in virgola mobile, e ci possono essere caratteri con significati speciali all'interno delle stringhe fra virgolette. In questi casi, ha senso che vengano composti tipograficamente in modo diverso rispetto al testo circostante, in modo che siano riconoscibili facilmente. Quindi anche se non rappresentano un contesto speciale, possono essere visti in tal modo dal sistema di evidenziazione, perché possano essere resi in modo diverso. + +Una definizione di sintassi può contenere tanti stili quanti sono richiesti per coprire i concetti del formato per cui è usata. + +In molti formati, ci sono elenchi di parole che rappresentano un concetto specifico. Ad esempio nei linguaggi di programmazione, le istruzioni di controllo sono un concetto, i nomi dei tipi di dato sono un altro, le funzioni built-in di un linguaggio un terzo. Il sistema di evidenziazione di &kate; può usare questi elenchi per identificare ed indicare le parole del testo in modo da enfatizzare i concetti dei formati di testo. + + + + +Stili predefiniti + +Se apri un file sorgente C++ o &Java; o un documento HTML in &kate;, vedrai che anche se i formati sono diversi, e quindi parole diverse sono scelte per un trattamento speciale, i colori usati sono gli stessi. Ciò è dovuto al fatto che &kate; ha un elenco di stili predefiniti che sono usati nelle varie definizioni di sintassi. + +Ciò rende più semplice riconoscere concetti simili nei vari formati di testo. Ad esempio i commenti sono presenti in quasi tutti i linguaggi per la programmazione, gli script e l'annotazione, e se sono mostrati con lo stesso stile in tutti i linguaggi, non è necessario fermarsi a pensare per identificarli all'interno del testo. + + +Tutti gli stili di una definizione di sintassi usano uno degli stili predefiniti. Alcune definizioni di sintassi usano più stili di quelli presenti fra i predefiniti, quindi se usi spesso un formato, può essere utile avviare la finestra di configurazione per vedere se alcuni concetti usano lo stesso stile. Ad esempio c'è un solo stile predefinito per le stringhe, ma poiché il linguaggio di programmazione Perl usa due tipi di stringhe distinti, puoi migliorare l'evidenziazione configurando i due tipi per avere un aspetto leggermente diverso. Tutti gli stili predefiniti disponibili sono spiegati in dettaglio in seguito. + + + + + + + +Il formato &XML; di definizione dell'evidenziazione + + +Panoramica + +Questa sezione è una panoramica del formato &XML; di definizione dell'evidenziazione. Partendo da un breve esempio, descriverà le componenti principali ed il loro significato ed uso. La sezione successiva approfondirà i dettagli delle regole di identificazione per l'evidenziazione. + +La definizione formale, anche nota come DTD, è memorizzata nel file language.dtd che dovrebbe essere installato sul tuo sistema nella cartella $KDEDIR/share/apps/katepart/syntax. + + +Sezioni principali dei file di definizione dell'evidenziazione di &kate; + + +Un file di evidenziazione contiene un'intestazione che stabilisce la versione di XML ed il tipo di documento: + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE language SYSTEM "language.dtd"> + + + + + +La radice del file di definizione è l'elemento language. Gli attributi disponibili sono: + + +Attributi obbligatori: +name definisce il nome del linguaggio. Apparirà nei menu e nelle finestre di dialogo. +section specifica la categoria. +extensions definisce le estensioni dei file, come "*.cpp,*.h" + +Attributi opzionali: +mimetype associa i file basati sui tipi &MIME;. +version specifica la versione attuale del file di definizione. +kateversion specifica l'ultima versione di &kate; supportata. +casesensitive specifica se le parole chiave fanno distinzione fra maiuscole e minuscole o no. +priority è un campo necessario se un altro file di evidenziazione usa la stessa estensione. Il file di definizioni che ha la priorità più alta vince. +author contiene il nome dell'autore ed il suo indirizzo di posta elettronica. +license contiene la licenza di distribuzione, solitamente LGPL, Artistic, GPL o altre. +hidden definisce se il nome debba apparire nei menu di &kate;. +Quindi la successiva riga potrebbe assomigliare a questa: +<language name="C++" version="1.00" kateversion="2.4" section="Sources" extensions="*.cpp;*.h" /> + + + + + + +Segue l'elemento highlighting, che contiene l'elemento opzionale list, e gli elementi obbligatori contexts e itemDatas. + +Gli elementi list contengono un elenco di parole chiave. In questo caso le parole chiave sono class e const. Puoi aggiungerne tante quante ne servono. +L'elemento contexts contiene tutti i contesti. Quindi il primo contesto è normalmente quello iniziale per l'evidenziazione. Ci sono due regole nel contesto Normal Text, che corrisponde all'elenco di parole chiave con il nome unnome ed una regola che identifica le virgolette e cambia il contesto a string. Per approfondire la conoscenza delle regole vedi il prossimo capitolo. +La terza parte è l'elemento itemDatas. Contiene tutti gli stili di colore e di tipo di carattere necessari al contesto e alle regole. In questo esempio, gli itemData Normal Text, String e Keyword sono usati. +<highlighting> + <list name="somename"> + <item> class </item> + <item> const </item> + </list> + <contexts> + <context attribute="Normal Text" lineEndContext="#pop" name="Normal Text" > + <keyword attribute="Keyword" context="#stay" String="somename" /> + <DetectChar attribute="String" context="string" char="&quot;" /> + </context> + <context attribute="String" lineEndContext="#stay" name="string" > + <DetectChar attribute="String" context="#pop" char="&quot;" /> + </context> + </contexts> + <itemDatas> + <itemData name="Normal Text" defStyleNum="dsNormal" /> + <itemData name="Keyword" defStyleNum="dsKeyword" /> + <itemData name="String" defStyleNum="dsString" /> + </itemDatas> + </highlighting> + + + + + +L'ultima parte della definizione dell'evidenziazione è l'opzionale sezione general. Può contenere informazioni sulle parole chiave, sul raggruppamento del codice, sui commenti e sull'indentazione. + + +La sezione comment definisce quale sequenza di caratteri introduce un commento su riga singola. Puoi definire anche commenti su più righe usando multiLine con l'attributo aggiuntivo end. Questo è usato se l'utente attiva le azioni per commentare/decommentare. +La sezione keywords definisce se le liste di parole chiave fanno distinzione fra le maiuscole e le minuscole o no. Altri attributi saranno spiegati successivamente. +<general> + <comments> + <comment name="singleLine" start="#"/> + </comments> + <keywords casesensitive="1"/> + </general> +</language> + + + + + + + + + + +Le sezioni nel dettaglio +Questa parte descrive tutti gli attributi disponibili per i tag contexts, itemData, keywords, comment, per le pieghe del codice e per l'indentazione. + + + +L'elemento context appartiene al gruppo contexts. Un contesto definisce le regole specifiche di un contesto, come che cosa debba succedere se il sistema di evidenziazione raggiunge un fine riga. Gli attributi disponibili sono: + + + +name specifica il nome del contesto. Le regole useranno questo nome per specificare il contesto da usare se la regola corrisponde. +lineEndContext definisce il contesto che verrà usato dal sistema di evidenziazione quando raggiunge la fine di una riga. Ciò può essere il nome di un altro contesto, o #stay per non cambiare contesto (cioè non far niente) o #pop che causa l'uscita dal contesto attuale. È possibile usare per esempio #pop#pop#pop per risalire di tre livelli. +lineBeginContext definisce il contesto se l'inizio di una riga è incontrato. Valore predefinito: #stay. +falltrough definisce se il sistema di evidenziazione commuta sul contesto specificato in fallthroughContext in caso di nessuna corrispondenza con una regola. Valore predefinito: false. +fallthroughContext specifica il contesto successivo se nessuna regola corrisponde. +dynamic se vale true fa in modo che il contesto ricordi le stringhe/segnaposto salvati dalle regole dinamiche. Ciò è necessario per i documenti HERE, ad esempio. Valore predefinito: false. + + + + + +L'elemento itemData è nel gruppo itemDatas. Definisce lo stile dei caratteri ed i colori. Quindi puoi definire stili e colori come preferisci, ma è buona norma usare gli stili predefiniti se possibile, in modo da usare gli stessi colori in linguaggi diversi. Però a volte non c'è altro modo ed è necessario cambiare gli attributi di colore e tipo di carattere. Gli attributi name e defStyleNum sono obbligatori, gli altri facoltativi. Gli attributi disponibili sono: + + +name fornisce il nome dell'itemData. I contesti e le regole useranno tale nome nell'attributo attribute per riferirsi ad un itemData. +defStyleNum definisce quale stile predefinito usare. Gli stili predefiniti sono spiegati nel dettaglio più avanti. +color definisce un colore. I formati validi sono "#rrvvbb" o "#rvb". +selColor definisce il colore della selezione. +italic se vale true, il testo sarà in corsivo. +bold se è true, il testo sarà in grassetto. +underline se è true, il testo sarà sottolineato. +strikeout se è true, il testo sarà barrato. + + + + + +L'elemento keywords nel gruppo general definisce le proprietà delle parole chiave. Gli attributi disponibili sono: + + +casesensitive può esser true o false. Se è true tutte le parole chiave verranno confrontate facendo distinzione tra maiuscole e minuscole. +weakDeliminator è un elenco di caratteri che non si comportano come delimitatori di parole. Ad esempio il punto "." è un delimitatore di parola. Assumendo che una parola chiave contenga un punto, potrà corrispondere al testo solo se il punto viene definito come delimitatore debole. +additionalDeliminator definisce delimitatori aggiuntivi. +wordWrapDeliminator definisce i caratteri dopo i quali è ammissibile un a capo automatico. +I delimitatori predefiniti ed i delimitatori di confine parola sono i caratteri .():!+,-<=>%&*/;?[]^{|}~\, spazio (' ') e tabulazione ('\t'). + + + + + +L'elemento comment del gruppo comments definisce le proprietà dei commenti che sono usate per StrumentiCommenta e StrumentiDecommenta. Gli attributi disponibili sono: + + +name è o singleLine o multiLine. Se scegli multiLine gli attributi end e region sono obbligatori. +start definisce la stringa usata per iniziare un commento. In C++ questa sarebbe "/*". +end definisce la stringa usata per chiudere un commento. In C++ essa sarebbe "*/". +region deve essere il nome del commento su più righe raggruppabile. Poniamo che tu abbia beginRegion="Comment" ... endRegion="Comment" fra le regole; in questo caso devi usare region="Comment". Così decommentare è possibile anche senza selezionare tutto il testo del commento su più righe. Basta che il cursore sia all'interno del commento. + + + + + +L'elemento folding del gruppo general definisce le proprietà del raggruppamento. Gli attributi disponibili sono: + + +indentationsensitive se true, gli indicatori di raggruppamento del codice saranno aggiunti in base all'indentazione, come per il linguaggio per gli script Python. Di solito non è necessaria una dichiarazione esplicita, perché in assenza di dichiarazione, viene considerato false. + + + + + +L'elemento indentation del gruppo general definisce quale algoritmo di indentazione verrà usato, ma si raccomanda fortemente di omettere questo elemento, perché l'indentatore verrà normalmente scelto o con la definizione di un tipo di file o con l'aggiunta di una variabile del documento nel file di testo. Se specifichi un indentatore invece, obbligherai l'utente ad usare un sistema di indentazione particolare, che potrebbe non gradire. Gli attributi disponibili sono: + + +mode è il nome dell'indentatore. Gli indentatori disponibili attualmente sono: normal, cstyle, csands, xml, python e varindent. + + + + + + + + + + +Stili predefiniti disponibili +Gli stili predefiniti sono stati già spiegati, ma riassumendo: gli stili predefiniti sono gli stili di colorazione e dei tipi di carattere. + + +Ecco quindi un elenco degli stili predefiniti disponibili: + +dsNormal, usato per il testo normale. +dsKeyword, usato per le parole chiave. +dsDataType, usato per i tipi di dato. +dsDecVal, usato per i valori decimali. +dsBaseN usato per i valori con una base diversa da 10. +dsFloat, usato per i valori in virgola mobile. +dsChar, usato per i singoli caratteri. +dsString, usato per le stringhe. +dsComment, usato per i commenti. +dsOther, usato per "altre" cose. +dsAlert, usato per i messaggi di attenzione. +dsFunction, usato per le chiamate di funzione. +dsRegionMarker, usato per gli indicatori di regione. +dsError, usato per l'evidenziazione degli errori e per la sintassi sbagliata. + + + + + + + + + +Regole per la determinazione dell'evidenziazione + +Questa sezione descrive le regole per la determinazione dell'evidenziazione. + +Ogni regola può corrispondere a zero o più caratteri all'inizio della stringa con cui sono confrontati. Se la regola corrisponde, ai caratteri corrispondenti è assegnato lo stile o l'attributo definito dalla regola, ed una regola può chiedere di cambiare il contesto attuale. + +Una regola ha questo aspetto: + +<RuleName attribute="(identificatore)" context="(identificatore)" [attributi specifici della regola] /> + +attribute identifica per nome lo stile da usare per i caratteri corrispondenti alla regola, e context identifica il contesto da usare da questo punto in poi. + +Il contesto può essere identificato da: + + + +Un identificatore, che è il nome di un altro contesto. + + +Un ordine che indica al motore di stare nel contesto attuale (#stay) o di tornare ad un contesto precedentemente usato nella stringa (#pop). +Per tornare indietro di più di un passo, la parola chiave #pop può essere ripetuta: #pop#pop#pop + + + +Alcune regole possono avere regole figlie che sono valutate solo se la regola madre corrisponde. All'intera stringa corrispondente sarà dato l'attributo della regola madre. Una regola con delle regole figlie ha questo aspetto: + +<RuleName (attributes)> + <ChildRuleName (attributes) /> + ... +</RuleName> + + + +Gli attributi specifici di ogni regola variano e sono descritti nelle sezioni seguenti. + + + +Attributi comuni +Tutte le regole hanno i seguenti attributi in comune che sono disponibili ogni volta che appare attributi comuni). attribute e context sono attributi obbligatori, gli altri sono facoltativi. + + +attribute: un attributo si applica ad un itemData definito. + + +context: Specifica il contesto da usare nel caso in cui la regola corrisponda. + + +beginRegion: inizia un blocco di ripiegamento del codice. Valore predefinito: non impostato. + + +endRegion: chiude un blocco di ripiegamento del codice. Valore predefinito: non impostato. + + +lookAhead Se vale true il sistema di evidenziazione non processa la lunghezza combaciante. Valore predefinito: false. + + +firstNonSpace: corrisponde solo se la stringa è composta dai primi caratteri non bianchi di una riga. Valore predefinito: false. + + +column: Corrisponde solo se la colonna corrisponde. Valore predefinito: non impostato. + + + + +Regole dinamiche +Alcune regole permettono l'uso dell'attributo dynamic di tipo booleano, con valore predefinito false. Se dynamic è true, una regola può usare segnaposto rappresentanti il testo corrispondente da una regola espressione regolare che cambia il contesto attuale nel suo attributo string o char. Se si usa string, il segnaposto %N (dove N è un numero) sarà sostituito con la corrispondente cattura N dell'espressione regolare. In un char il segnaposto deve essere un numero N e sarà sostituito con il primo carattere della corrispondente cattura N dell'espressione regolare chiamante. Quando una regola permette questo attributo, conterrà nella sinossi la dicitura (dynamic). + + +dynamic può essere (true|false). + + + + +Le regole nel dettaglio + + + +DetectChar + +Identifica un singolo carattere specifico. Usata comunemente per trovare ad esempio la fine di una stringa virgolettata. +<DetectChar char="(carattere)" (attributi comuni) (dynamic) /> +L'attributo char definisce il carattere che deve corrispondere. + + + + +Detect2Chars + +Identifica due caratteri specifici in un ordine stabilito. +<Detect2Chars char="(carattere)" char1="(carattere)" (attributi comuni) (dynamic) /> +L'attributo char definisce il primo carattere che deve corrispondere, char1 il secondo. + + + + +AnyChar + +Identifica un carattere appartenente ad uno specifico insieme di caratteri. +<AnyChar String="(stringa)" (attributi comuni) /> +L'attributo String definisce l'insieme di caratteri. + + + + +StringDetect + +Identifica una stringa esattamente corrispondente. +<StringDetect String="(stringa)" [insensitive="true|false"] (attributi comuni) (dynamic) /> +L'attributo String definisce la stringa da confrontare. L'attributo insensitive vale false, se omesso, ed è passato alla funzione per la comparazione delle stringhe. Se il suo valore è true, verrà usata una comparazione senza distinzione fra maiuscole e maiuscole. + + + + +RegExpr + +Corrispondenza con un'espressione regolare. +<RegExpr String="(stringa)" [insensitive="true|false"] [minimal="true|false"] (attributi comuni) (dynamic) /> +L'attributo String definisce l'espressione regolare. +insensitive vale false normalmente,ed è passato al motore delle espressioni regolari. +minimal vale false normalmente,ed è passato al motore delle espressioni regolari. +Poiché le regole sono confrontate sempre con l'inizio della stringa corrente, un'espressione regolare che inizi con un carattere di accento circonflesso (^) indica che la regola debba combaciare solo all'inizio di una riga. +Vedi la sezione sulle espressioni regolari per maggiori informazioni a riguardo. + + + + +keyword + +Rivela una parola chiave da un elenco specificato. +<keyword String="(nome lista)" (attributi comuni) /> +L'attributo String identifica la lista di parole chiave per nome. Deve essere presente una lista con tale nome. + + + + +Int + +Rivela un numero intero. +<Int (attributi comuni) (dynamic) /> +Questa regola non ha attributi specifici. Le regole figlie di solito si usano per trovare combinazioni di L e U dopo un numero, per indicare il tipo di intero nel codice di un programma. In effetti tutte le regole sono ammesse come regole figlie, anche se il DTD permette solo la regola figlia StringDetect. +L'esempio seguente corrisponde ai numeri interi seguiti dal carattere "L". <Int attribute="Decimal" context="#stay" > + <StringDetect attribute="Decimal" context="#stay" String="L" insensitive="true"/> +</Int> + + + + + + +Float + +Rivela un numero in virgola mobile. +<Float (attributi comuni) /> +Questa regola non ha attributi specifici. AnyChar è ammesso come regola figlia ed è tipicamente usata per identificare le combinazioni, vedi la regola Int come riferimento. + + + + +HlCOct + +Rivela la rappresentazione ottale di un numero. +<HlCOct (attributi comuni) /> +Questa regola non ha attributi specifici. + + + + +HlCHex + +Rivela la rappresentazione esadecimale di un numero. +<HlCHex (attributi comuni) /> +Questa regola non ha attributi specifici. + + + + +HlCStringChar + +Rivela una sequenza di escape. +<HlCStringChar (attributi comuni) /> +Questa regola non ha attributi specifici. + +Corrisponde a rappresentazioni letterali di caratteri comunemente usati nel codice dei programmi, come ad esempio \n (nuova riga) o \t (TAB). + +Corrisponde ai seguenti caratteri se seguono una barra inversa (\): abefnrtv"'?\. In più, corrisponde alle sequenze di escape con i numeri esadecimali come \xff e con i numeri ottali, come \033. + + + + + +HlCChar + +Rivela un carattere C. +<HlCChar (attributi comuni) /> +Questa regola non ha attributi specifici. + +Corrisponde ai caratteri C racchiusi fra apici singoli (Esempio: 'c'). Quindi fra gli apici può trovarsi un carattere semplice o un carattere preceduto da un carattere di escape. Vedi HlCStringChar per sapere quali sequenze di escape siano contemplate. + + + + + +RangeDetect + +Identifica una stringa con dei caratteri di inizio e fine definiti. +<RangeDetect char="(carattere)" char1="(carattere)" (attributi comuni) /> +char definisce il carattere che inizia la sequenza, char1 il carattere che termina la sequenza. +È utile per trovare ad esempio brevi stringhe racchiuse fra virgolette o simili, ma nota che poiché il motore di evidenziazione funziona ad una riga per volta, questa regola non può trovare stringhe che continuano su più di una riga. + + + + +LineContinue + +Corrisponde alla fine di una riga. +<LineContinue (attributi comuni) /> +Questa regola non ha attributi specifici. +Questa regola è utile per cambiare contesto alla fine di una riga, se l'ultimo carattere è una barra inversa ('\'). Ciò è necessario ad esempio in C/C++ per continuare le macro o le stringhe. + + + + +IncludeRules + +Include regole di un altro contesto o di un altro linguaggio o file. +<IncludeRules context="linkAContesto" [includeAttrib="true|false"] /> + +L'attributo context definisce quale contesto includere. +Se è una semplice stringa, include tutte le regole definite nel contesto attuale, ad esempio: <IncludeRules context="unAltroContesto" /> + +Se la stringa comincia con ## il sistema di evidenziazione cercherà un'altra definizione di linguaggio con il nome dato, ad esempio: <IncludeRules context="##C++" /> +Se l'attributo includeAttrib è true, cambia l'attributo di destinazione a quello del sorgente. Ciò è necessario, ad esempio, per far funzionare i commenti, se il testo a cui corrisponde il contesto incluso è di evidenziazione diversa da quello del contesto ospite. + + + + + +DetectSpaces + +Rileva gli spazi bianchi. +<DetectSpaces (attributi comuni) /> + +Questa regola non ha attributi specifici. +Usa questa regola se sai che si possono incontrare molti spazi bianchi, ad esempio all'inizio di righe indentate. La regola salta tutti gli spazi in una volta, invece di provare più regole e saltarne uno per volta per mancanza di corrispondenza. + + + + + +DetectIdentifier + +Rivela le stringhe degli identificatori (come espressione regolare: [a-zA-Z_][a-zA-Z0-9_]*). +<DetectIdentifier (attributi comuni) /> + +Questa regola non ha attributi specifici. +Usa questa regola per saltare una stringa di caratteri di parola in una volta, invece di provare più regole per saltare un carattere per volta per mancanza di corrispondenza. + + + + + + + +Suggerimenti e trucchi + + +Quando avrai capito come funziona il cambio di contesto sarà facile scrivere le tue definizioni. Però devi stare attento a quali regole scegli in quale situazione. Le espressioni regolari sono potenti, ma sono lente in confronto alle altre regole. Quindi ti conviene seguire i seguenti consigli. + + +Se devi confrontare solo due caratteri, usa Detect2Chars invece di StringDetect. Lo stesso si applica a DetectChar. + + +Le espressioni regolari sono comode ma spesso c'è un modo molto più veloce per ottenere lo stesso risultato. Considera di volere una corrispondenza co il carattere '#' se è il primo carattere di una riga. Una soluzione basata sulle espressioni regolari avrà questo aspetto: <RegExpr attribute="Macro" context="macro" String="^\s*#" /> Puoi ottenere lo stesso effetto molto più rapidamente usando: <DetectChar attribute="Macro" context="macro" char="#" firstNonSpace="true" /> Se vuoi una corrispondenza con l'espressione regolare'^#' puoi comunque usare DetectChar con l'attributo column="0". L'attributo column conta le colonne in base ai caratteri, quindi un tabulatore è ancora un solo carattere. + + +Puoi cambiare contesto senza processare caratteri. Poniamo che tu voglia cambiare contesto quando incontri la stringa */, ma che debba processare la stringa nel prossimo contesto. La regola seguente corrisponderà, e l'attributo lookAhead farà mantenere all'evidenziatore la stringa corrispondente per il prossimo contesto. <Detect2Chars attribute="Comment" context="#pop" char="*" char1="/" lookAhead="true" /> + + + +Usa DetectSpaces se sai che capitano molti spazi bianchi. + + +Usa DetectIdentifier invece dell'espressione regolare '[a-zA-Z_]\w*'. + + +Usa gli stili predefiniti ogni volta che puoi. In questo modo l'utente si troverà in un ambiente familiare. + + +Esamina gli altri file XML per vedere come altri hanno implementato regole complesse. + + +Puoi convalidare tutti i file XML usando il comando xmllint --dtdvalid language.dtd miaSintassi.xml. + + +Se usi più volte delle espressioni regolari complesse, puoi usare le ENTITÀ. Esempio: +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE language SYSTEM "language.dtd" +[ + <!ENTITY myref "[A-Za-z_:][\w.:_-]*"> +]> + +Ora puoi usare &myref; invece dell'espressione regolare. + + + + + + + diff --git a/tde-i18n-it/docs/tdebase/kate/index.cache.bz2 b/tde-i18n-it/docs/tdebase/kate/index.cache.bz2 new file mode 100644 index 00000000000..3f7a5dcdbf6 Binary files /dev/null and b/tde-i18n-it/docs/tdebase/kate/index.cache.bz2 differ diff --git a/tde-i18n-it/docs/tdebase/kate/index.docbook b/tde-i18n-it/docs/tdebase/kate/index.docbook new file mode 100644 index 00000000000..686e24f3548 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/index.docbook @@ -0,0 +1,496 @@ + + + + + + + + + + + + + + +]> + + +Manuale di &kate; + + + +&Anders.Lund; &Anders.Lund.mail; +&Seth.Rothberg; &Seth.Rothberg.mail; +&Dominik.Haumann; &Dominik.Haumann.mail; +Nicola Ruggero
nicola@nxnt.org
Traduzione della documentazione.Luciano Montanaro
mikelima@cirulla.net
Traduzione della documentazione.Luigi Toscano
luigi.toscano@tiscali.it
Traduzione della documentazione. + + + +2000 +2001 +&Seth.Rothberg; + + +200220032005 +&Anders.Lund; + + +2005 +&Dominik.Haumann; + + +&FDLNotice; + +2005-12-29 +2.5.0 + + +&kate; è un editor avanzato di testi per &kde; 2.2 e superiore. + +Questo manuale si riferisce alla versione 2.5.0 di &kate; + + + +KDE +tdebase +Kate +testo +editor +programmatore +programmazione +progetti +MDI +Multi +Document +Interface +terminale +console + + + + + +Introduzione + +Benvenuto in &kate;, un editor avanzato di testi per &kde; versione 2.2 e superiore. Alcune delle caratteristiche di &kate; comprendono: la capacità di configurare la evidenziazione della sintassi per linguaggi che vanno dal C e C++ all'HTML e agli script di bash, la possibilità di creare e gestire progetti, possedere una interfaccia MDI (multiple document interface) e un terminale della console integrato. + +Ma &kate; è molto di più di editor avanzato di testi. La sua capacità di aprire diversi file contemporaneamente è ideale per modificare molti file di configurazione di &UNIX;. Questa documentazione, per esempio, è stata scritta con &kate;! + + + + +Scrittura di questo manuale... + + + + + +&fundamentals-chapter; + +&mdi-chapter; + +&part-chapter; + +&plugins-chapter; + +&advanced-chapter; + +&menu-chapter; + +&configuring-chapter; + + + +Riconoscimenti e licenza + +&kate;. Copyright 2000, 2001, 2002 - 2005 - La squadra di sviluppo di &kate;. + + +La squadra di &kate;: + +&Christoph.Cullmann; &Christoph.Cullmann.mail; +Responsabile progetto & sviluppatore principale + + +&Anders.Lund; &Anders.Lund.mail; +Sviluppatore principale, evidenziazione del linguaggio Perl, documentazione + + +&Joseph.Wenninger; &Joseph.Wenninger.mail; +Sviluppatore principale, Modalità di evidenziazione + + +Michael Bartl michael.bartl1@chello.at +Sviluppatore principale + + +Phlip phlip_cpp@my-deja.com +Compilatore del progetto + + +&Waldo.Bastian; &Waldo.Bastian.mail; +L'ingegnoso sistema di buffer + + +Matt Newell newellm@proaxis.com +Prove... + + +Michael McCallum gholam@xtra.co.nz +Sviluppatore principale + + +Jochen Wilhemly digisnap@cs.tu-berlin.de +Autori di KWrite + + +&Michael.Koch; &Michael.Koch.mail; +Port di KWrite su KParts + + +Christian Gebauer gebauer@bigfoot.com +Altro + + +&Simon.Hausmann; &Simon.Hausmann.mail; +Altro + + +Glen Parker glenebob@nwlink.com +Sistema di Annulla/Rifai con elenco azioni, integrazione con KSpell + + +Scott Manson sdmanson@alltel.net +Supporto per l'evidenziazione dei file XML in KWrite + + +&John.Firebaugh; &John.Firebaugh.mail; +Varie patch + + +&Dominik.Haumann; &Dominik.Haumann.mail; +Sviluppatore, procedura guidata evidenziazione + + + + +Molta altra gente che ha contribuito: + +Matteo Merli merlim@libero.it +Evidenziazione dei file RPM Spec, Diff e altro + + +Rocky Scaletta rocky@purdue.edu +Evidenziazione dei file VHDL + + +Yury Lebedev +Evidenziazione dei file SQL + + +Chris Ross +Evidenziazione dei file Ferite + + +Nick Roux +Evidenziazione dei file ILERPG + + +John Firebaugh +Evidenziazione del Java e molto di più + + +Carsten Niehaus +Evidenziazione per i file LaTeX + + +Per Wigren +Evidenziazione dei Makefiles e Python + + +Jan Fritz +Evidenziazione del Python + + +&Daniel.Naber; +Piccole correzioni bug, plugin XML + + + +Documentazione Copyright 2000,2001 &Seth.Rothberg; &Seth.Rothberg.mail; + +Documentazione Copyright 2002, 2003, 2005 &Anders.Lund; &Anders.Lund.mail; + +Documentazione tradotta da: Nicola Ruggero nicola@nxnt.org +&underFDL; &underGPL; + +&highlighting-appendix; + +®exp-appendix; + + +Installazione + +&install.intro.documentation; + +&install.compile.documentation; + + + +&documentation.index; + + + + + + diff --git a/tde-i18n-it/docs/tdebase/kate/man-kate.1.docbook b/tde-i18n-it/docs/tdebase/kate/man-kate.1.docbook new file mode 100644 index 00000000000..e9c3500301e --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/man-kate.1.docbook @@ -0,0 +1,294 @@ + + +]> + + + +Manuale utente di KDE +&Lauri.Watts; &Lauri.Watts.mail; +7 giugno 2005 Ambiente desktop K + + +kate +1 + + + +kate +Editor di testo avanzato per &kde; + + + +kate nome pid nome riga colonna Opzioni generiche di KDE Opzioni generiche di Qt + + + +Descrizione +&kate; è l'editor di testo avanzato per &kde;. +&kate; fornisce anche il componente per la modifica del testo di varie applicazioni, con il nome di &kwrite;. +Alcune delle molte funzioni di &kate; includono l'evidenziazione della sintassi configurabile per molti linguaggi da C e C++ a HTML, a script bash, all'abilità di creare e fare manutenzione su progetti, un'interfaccia basata su documenti multipli (MDI), ed un emulatore di terminale a sé stante. + +Ma &kate; è molto più di un editor avanzato di testi. La sua capacità di aprire diversi file contemporaneamente è ideale per modificare i molti file di configurazione di &UNIX;. Questo documento, ad esempio, è stato scritto con &kate;! + + + + + +Opzioni + + + +, nome + +Avvia &kate; con una sessione data. + + + +Usa un'istanza di &kate; già in esecuzione + + + pid +Prova a riutilizzare solo l'istanza di kate con questo pid + + + nome +Imposta la codifica per il file da aprirePuoi usare questa opzione per costringere l'apertura di un file con la codifica utf-8, ad esempio (Il comando iconv -l fornisce un elenco delle codifiche che possono esserti utili). + + + riga +Spostati a questa riga + + + colonna +Spostati a questa colonna + + + +Leggi il contenuto di stdin + + + + + + +Vedi anche + +kwrite(1) + +Documentazione per l'utente più dettagliata è disponibile usando help:/kate (inserisci questo URL in &konqueror; o avvia khelpcenter help:/kate). + +Ulteriori informazioni sono inoltre disponibili presso il sito web di &kate;. + + + +Esempi + +Per aprire un file dal nome sorgente.cpp alla colonna 15 della riga 25 in una finestra esistente di &kate; potresti usare: +kate sorgente.cpp + +Se hai una connessione internet attiva puoi sfruttare la trasparenza alla rete di &kde; per aprire un file da un sito FTP. Se non hai i permessi di scrittura sul server remoto, il file sarà aperto in modalità di sola lettura e ti verrà chiesto un nome per il file locale da usare per salvare le tue eventuali modifiche. Se hai i permessi di scrittura, le modifiche saranno salvate in modo trasparente sulla rete. +kate + + + + + + + + +Autori +Il responsabile di &kate; è &Christoph.Cullmann; &Christoph.Cullmann.mail;. Un elenco completo degli autori e dei collaboratori è disponibile nel manuale per l'utente completo summenzionato. + + + diff --git a/tde-i18n-it/docs/tdebase/kate/mdi.docbook b/tde-i18n-it/docs/tdebase/kate/mdi.docbook new file mode 100644 index 00000000000..2a708a0b3da --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/mdi.docbook @@ -0,0 +1,366 @@ + + + +&Anders.Lund; &Anders.Lund.mail; +Nicola Ruggero
nicola@nxnt.org
Traduzione della documentazione. + + +Lavorare con &kate; <acronym +>MDI</acronym +> + + +Panoramica + +Finestra, Vista, Documento, Cornice, Editor... Che cosa sono tutti queste voci nella terminologia di &kate;, e come ottenerne il massimo? Questo capitolo spiegherà tutte queste cose e molto di più. + + + +La finestra principale + +Finestra principale La finestra principale di &kate; è una finestra standard di &kde; con l'aggiunta di barre laterali contenenti viste degli strumenti. Possiede una barra dei menu con tutti i menu più comuni e qualcun altro, e infine una barra degli strumenti che fornisce l'accesso ai comandi usati più comunemente. + +La parte più importante della finestra è l'area dell'editor che, per impostazione predefinita, visualizza un solo componente dell'editor di testo, nel quale puoi lavorare con i tuoi documenti. + +La capacità di agganciarsi del pannello è usata per i pannelli degli strumenti: + + +La lista dei file +Il selettore file +Il Terminale integrato + + +E forse altri pannelli di strumenti, per esempio forniti da un plugin. + +Le viste degli strumenti possono essere posizionate in una barra laterale; per muovere uno strumento fai clic sul suo pulsante dalla barra e selezionalo dal menu &RMB;. + +La vista di uno strumento può essere indicata come persistente dal menu del &RMB;. La barra laterale può contenere più strumenti per volta, in modo che quando uno strumento è persistente gli altri possono essere mostrati in contemporanea. + + + + + + + + +L'Area dell'editor + +Area dell'editor &kate; ha la capacità di avere più di un documento aperto allo stesso tempo, e inoltre di dividere l'area dell'editor in qualsiasi numero di finestre, in maniera simile a &konqueror; o al popolare emacs. In questa maniera puoi vedere diversi documenti allo stesso tempo, o più istanze dello stesso documento, per esempio se il tuo documento contiene definizioni all'inizio e le vuoi vedere spesso per riferimento. Oppure puoi vedere l'header del sorgente di un programma in una finestra, mentre modifichi il file di implementazione in un'altra. + +Quando un documento è disponibile in più di un editor, i cambiamenti effettuati su uno degli editor saranno immediatamente riflessi negli altri. Questo include la selezione e la modifica del testo. Le operazioni di ricerca o i movimenti del cursore si rifletteranno solo nell'editor corrente. + +Attualmente non è possibile avere più istanze aperte dello stesso documento, nel senso che in una istanza compaiono le modifiche che si stanno facendo mentre nell'altra no. + +Quando dividi l'editor in due finestre, è diviso in due finestre della stessa dimensione. Entrambe le finestre visualizzano il documento corrente su cui stai lavorando. La nuove finestra sarà in basso (nel caso in cui dividi orizzontalmente) o a destra (quando dividi verticalmente). La nuova finestra sarà resa attiva e si noterà da un piccolo led verde. + + + + +L'elenco dei documenti + +Lista dei file La lista dei file mostra una lista di tutti i documenti attualmente aperti in &kate;. Il file modificati avranno una piccola icona di un Dischetto a sinistra che indica il loro stato. + +Se due o più file con lo stesso nome (situati in cartelle diverse) sono aperti, al nome del secondo e successivi verrà aggiunto un <2> e così via. Il suggerimento del file mostrerà il suo nome e percorso completo, permettendoti di scegliere quello che desideri. Per visualizzare un documento nella finestra attiva, fai clic sul nome del documento nella lista. + +Puoi ordinare l'elenco in alcuni modi diversi facendo clic con il tasto destro e selezionando una voce dal menu Ordina per. Le opzioni sono: + + +Ordine di apertura +Elenca i documenti nell'ordine di apertura + + + +Nome documento +Elenca i documenti alfabeticamente per nome. + + + +URL +Elenca i documenti alfabeticamente per URL. + + + + + + +L'elenco dei documenti normalmente mostra la cronologia ombreggiando il colore di sfondo delle voci dei documenti più recenti. Se il documento viene modificato, vene miscelato un altro colore. I documenti più recenti hanno colori più vivi, quindi è facile trovare i document su cui stai lavorando. Questa funzione può essere disabilitata dalla pagina Lista documenti del pannello di configurazione. + +La posizione standard nella finestra di &kate; è a sinistra dell'area dell'editor. + + + +Il selettore file + +Selettore file Il Selettore file è un visualizzatore delle cartelle che permette di aprire i file da una cartella aperta nella riquadro attuale. + +Dall'alto al basso, il selettore file è composto dai seguenti elementi: + + + +Una barra degli strumenti + +Questa contiene pulsanti standard per la navigazione: + + +Home +Premendolo farai in modo che la visualizzazione della cartella si posizioni con un cd nella tua home directory. + + +Su +Questo fa in modo che la cartella si posizioni, con un cd, nella cartella di livello immediatamente superiore alla cartella visualizzata. Ovviamente se questo è possibile. + + +Indietro +Fa in modo che la vista della cartella si sposti, con un cd, alla precedente cartella visualizzata in ordine cronologico. Questo pulsante è disabilitato se non c'è un elemento precedente in cronologia. + + +Avanti +Provoca lo spostamento della vista cartella, tramite comando cd, alla cartella successiva nella cronologia. Questo pulsante è disattivato se non esiste una cartella successiva nella cronologia. + + +Sincronizza +Questo pulsante provoca lo spostamento della vista cartella, tramite comando cd, alla cartella che contiene il documento che è attualmente attivo (se possibile). Questo pulsante è disabilitato se il documento attivo è un nuovo file che non è ancora stato salvato oppure se la cartella in cui risiede non è individuabile. + + + + + + + +Il campo &URL; + +Qui puoi digitare il percorso di una cartella da sfogliare. Il campo &URL; mantiene una lista di tutti i percorsi precedentemente inseriti. Per sceglierne uno usa il pulsante con la freccia a destra del campo. +Il campo &URL; ha il completamento automatico dei nomi delle cartelle. Il metodo di completamento può essere impostato utilizzando il menu &RMB; del campo di inserimento. + + + + +La Vista cartelle +Questa è una vista cartelle standard di &kde;. + + + +Il campo Filtro + +Il campo Filtro ti permette di definire un filtro per i file visualizzati nella vista cartella. Il filtro usa pattern standard. Ognuno di essi deve essere separato da uno spazio vuoto. Esempio: *.cpp *.h *.moc +Per visualizzare tutti i file, inserisci un asterisco singolo *. +Il campo filtro salva gli ultimi 10 filtri inseriti durante la sessione. Per usarne uno fai clic sul pulsante con la freccia a destra del campo di inserimento e seleziona il filtro che desideri. + + + + + + + + + +Il terminale integrato + +Terminale integrato Il terminale integrato è una copia della &konsole;: il terminale di &kde;, per tua comodità. È disponibile dal menu ImpostazioniMostra terminale oppure premendo il tasto F7. Appena viene visualizzato la sua finestra diviene attiva. Inoltre, se l'opzione Sincronizza &konsole; con il documento attivo è abilitata, il terminale cambia directory per posizionarsi, se possibile, in quella del documento corrente; quando è visualizzato oppure quando il documento cambia. + +La posizione standard nella finestra di &kate; è in basso, sotto l'area dell'editor. + +Puoi configurare la &konsole; usando il suo menu &RMB;. Per ulteriori informazioni vedi il manuale di &konsole;. + + + + +Strumenti esterni + +Nel menu Strumenti troverai un sottomenu chiamato Strumenti esterni. Questi strumenti invocano applicazioni esterne con i dati relativi al documento attuale, ad esempio il suo URL, la sua directory o il testo selezionato. + +Gli strumenti esterni sono definibili dall'utente; puoi aggiungerli, modificarli o rimuoverli usando il pannello di configurazione Strumenti esterni. + + + + diff --git a/tde-i18n-it/docs/tdebase/kate/menus.docbook b/tde-i18n-it/docs/tdebase/kate/menus.docbook new file mode 100644 index 00000000000..4d3aab7f698 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/menus.docbook @@ -0,0 +1,2224 @@ + + + + +LucianoMontanaro
mikelima@cirulla.net
Traduzione + + +Voci del Menu + + +Il menu <guimenu +>File</guimenu +> + + + + + + &Ctrl;N File Nuovo + + +Questo comando crea un nuovo documento nella finestra di modifica. Nella lista Documenti sulla sinistra il nuovo file è indicato come Senza titolo. + + + + + + + &Ctrl;O File Apri... + + +Apre la finestra di dialogo di apertura file di &kde; per permetterti di aprire uno o più file. + + + + + + + +File Apri recenti + + +Permette di aprire un file da un sottomenu contenente una lista di file modificati di recente. + + + + + + +FileApri con + + +Questo sottomenu presenta una lista di applicazioni in grado di gestire il tipo MIME del documento attuale. Attivando una voce verrà aperto il documento attuale con l'applicazione relativa. +Inoltre, la voce Altro... apre una finestra di dialogo per selezionare un'altra applicazione per l'apertura del file attivo. Il file resterà aperto anche in &kate;. + + + + + + + &Ctrl;S File Salva + + +Questo comando salva il file. Usalo spesso. Se il file è senza titolo, allora Salva si comporta come Salva con nome.... + + + + + + +File Salva con nome... + + +Dai un nome o rinomina i file con questo comando. Apre la finestra di salvataggio dei file. La finestra funziona in modo simile a quella di apertura dei file. Puoi usarla per muoverti all'interno del filesystem, per vedere l'anteprima di file esistenti o filtrare la vista con delle maschere. + +Scrivi il nome che vuoi dare al file che stai per salvare nella casella combinata Indirizzo e premi il pulsante OK. + + + + + + +&Ctrl; LFileSalva tutto + + +Questo comando salva tutti i file aperti che sono stati modificati. + + + + + + + F5 File Ricarica + + +Ricarica il file attivo. Questa azione è utile se un altro programma ha cambiato il file mentre lo hai aperto in &kate; + + + + + + + &Ctrl;P File Stampa... + + +Stampa il file attivo. + + + + + +File Esporta come HTML... + + +Esporta il file nel formato HTML in modo che possa essere visualizzato come una pagina web. + + + + + +File Spedisci... + + +Apre il client di posta elettronica ed allega il file al messaggio. + + + + + + + &Ctrl;W File Chiudi + + +Questa voce chiude il file attivo. Se hai fatto delle modifiche senza salvarle, ti verrà chiesto se salvare le modifiche prima che &kate; lo chiuda. + + + + + + +File Chiudi tutto + + +Questo comando chiude tutti i file che hai aperto in &kate;. + + + + + + + &Ctrl;Q File Esci + + +Questo comando chiude &kate; e tutti i file che stavi modificando. Se hai delle modifiche non salvate in uno o più file, ti verrà chiesto se vuoi salvarle. + + + + + + +Il menu <guimenu +>Modifica</guimenu +> +Il menu Modifica contiene un numero di azioni che operano tutte sul documento attualmente attivo. + + +Voci del Menu + + + +&Ctrl;Z Modifica Annulla + + +Annulla l'ultima azione di modifica (inserimento di testo, copia, taglio ecc.) +Se l'annullamento raggruppato è attivo, verranno annullati più comandi di modifica dello stesso tipo, come l'inserimento di caratteri. + + + + + + +&Ctrl;&Shift;Z Modifica Rifai + + +Rifa l'ultimo passo di annullamento. + + + + + + +&Ctrl;X Modifica Taglia + + +Rimuove il testo selezionato, se c'è una selezione attiva, e ne mette una copia negli appunti di sistema. + + + + + + +&Ctrl;C Modifica Copia + + +Copia il testo selezionato negli appunti. + + + + + + +ModificaCopia come HTML + + +Copia il testo selezionato con l'evidenziazione della sintassi come testo HTML. + + + + + + +&Ctrl;V Modifica Incolla + + +Copia la prima voce degli appunti nell'editor alla posizione del cursore. +Se l'opzione Sovrascrivi selezione è attiva, il testo incollato sovrascriverà la selezione, se è presente. + + + + + + +&Ctrl;A Modifica Seleziona tutto + + +Seleziona tutto il testo nell'editor. + + + + + + +&Ctrl;&Shift;AModificaDeseleziona + + +Deseleziona il testo selezionato nell'editor, se è presente. + + + + + + +&Ctrl; Shift BModificaModalità selezione a blocchi + + +Cambia modalità di selezione. Quando la modalità di selezione è BLOCCO, puoi fare selezioni verticali, cioè selezionare le colonne dalla 5 alla 10 e le righe dalla 9 alla 15. +La barra di stato mostra lo stato attuale della modalità di selezione, o NORM o BLO. + + + + + + +&Ctrl;F Modifica Trova... + + +Apre la finestra Trova per permetterti di cercare del testo nel documento che stai modificando. + + + + + + +F3ModificaTrova successivo + + +Va alla corrispondenza successiva più vicina dell'ultimo testo o espressione regolare che hai cercato, iniziando dalla posizione del cursore + + + + + + +&Shift; ModificaTrova precedente + + +Va alla corrispondenza precedente più vicina dell'ultimo testo o espressione regolare che hai cercato, iniziando dalla posizione del cursore + + + + + + +&Ctrl;R Modifica Sostituisci... + + +Apre la finestra Sostituisci per sostituire una o più volte un certo testo con dell'altro. + + + + + + +&Ctrl;G ModificaVa alla riga + + +Apre la finestra Va alla riga, in modo da permettere di inserire un numero di riga da trovare nel documento + + + + + + + + +Il menu <guimenu +>Documento</guimenu +> +Il menu Documento ha una voce per ciascun documento aperto. Un clic sulla voce corrispondente porta in primo piano il documento richiesto. Se hai aperti più riquadri, il documento selezionato verrà mostrato nel riquadro attivo. +Inoltre sono presenti comandi per navigare fra i documenti aperti: +Voci del menu + + + + +&Alt;SinistraDocumentoIndietro + + +Porta il fuoco al documento precedente della pila. Se hai più riquadri aperti, il documento viene mostrato nel riquadro attivo. L'ordine usato è quello in cui i documenti sono stati aperti, invece della cronologia logica. Questo comportamento potrebbe cambiare in future versioni di &kate;. + + + + + + +&Alt;DestraDocumentoAvanti + + +Porta il fuoco al documento successivo della pila. Se hai più riquadri aperti, il documento viene mostrato nel riquadro attivo. +L'ordine usato è quello in cui i documenti sono stati aperti, invece della cronologia logica. Questo comportamento potrebbe cambiare in future versioni di &kate;. + + + + + + + +Il menu <guimenu +>Visualizza</guimenu +> + +Il menu Visualizza permette di gestire le impostazioni specifiche per l'editor corrente e di gestire i riquadri. + + +Voci del menu + + +VisualizzaPassa alla riga di comando +Questo comando commuta la visualizzazione della riga di comando integrata. + + + +VisualizzaSchema +Questo menu mostra tutti gli schemi disponibili. Puoi cambiare schema per la vista corrente da qui, per cambiare lo schema devi usare la finestra di configurazione. + + + + +F10 VisualizzaA capo automatico dinamico + +Attiva o disattiva l'a capo automatico della vista attuale. L'a capo automatico rende tutto il testo di una vista visibile senza usare lo scorrimento orizzontale, perché mostra una riga di testo effettivo su una o più righe, se è necessario. + + + + +VisualizzaMostra/nascondi indicatore a capo statico +Attiva o disattiva la visualizzazione della riga verticale che indica l'ampiezza della pagina come configurata nella finestra di configurazione. Questa funzione è disponibile solo se si usa un tipo di carattere a spaziatura fissa. + + + + + + +F6 Visualizza Mostra/Nascondi il bordo per le icone + + +Questa è una voce di commutazione. Sarà rispettivamente reso visibile o nascosto il bordo per le icone sul lato sinistro dell'editor attivo. + + + + + + +F11 Visualizza Mostra/Nascondi i numeri di riga + + +Questo è un elemento alternato. Attivandolo verrà riservato dello spazio sul bordo sinistro dell'editor attivo per visualizzare i numeri di riga del documento, Disattivandolo, i numeri di riga verranno nascosti. + + + + +VisualizzaMostra/nascondi segni nella barra di scorrimento +Attiva o disattiva la visualizzazione dei segnalibri (ed altri segni) sulla barra di scorrimento. Quando è attiva, gli indicatori sono rappresentati da sottili righe nel colore di evidenziazione sulla barra di scorrimento, un clic col tasto centrale del mouse farà scorrere la vista ad una posizione prossima all'indicatore. + + + +F9 VisualizzaMostra/Nascondi segni di raggruppamento +Attiva e disattiva la visualizzazione del pannello degli indicatori di raggruppamento sul lato sinistro della vista. Vedi Uso del raggruppamento del codice. + + + + + + +Raggruppamento codice + + + + + + +&Ctrl; Shift- Contrai livello superiore + +Contrae tutte le regioni di livello superiore nel documento. + + +&Ctrl;Shift+ Espandi livello superiore + +Espande tutte le regioni di livello superiore nel documento. + + +&Ctrl; - Contrai un livello locale + +Contrae la regione più vicina al cursore. + + +&Ctrl; + Espandi un livello locale + +Espande la regione più vicina al cursore. + + + + + + + + + + + +Il menu <guimenu +>Segnalibri</guimenu +> + +Il menu Segnalibri permette di lavorare con segnalibri nel documento attualmente attivo. + +Sotto le voci qui descritte, una voce per ciascun segnalibro nel documento attivo sarà disponibile. Il testo sarà composto dalle prime parole della riga indicata. Scegli una voce per spostare il cursore all'inizio della riga corrispondente. L'editor scorrerà il testo di quanto è necessario per rendere la riga visibile. + + + +Voci del menu + + + + +&Ctrl;B Segnalibri Metti/Pulisci segnalibro + + +Imposta o rimuove un segnalibro nella riga attuale del documento attivo (Se c'è un segnalibro viene rimosso, altrimenti viene impostato). + + + + + + +Segnalibri Pulisci tutti i segnalibri + + +Pulisce (elimina) tutti i segnalibri del documento attivo. + + + + +&Alt; Pagina SuSegnalibri Precedente + +Ciò sposterà il cursore all'inizio della prima riga in alto che abbia un segnalibro. Il testo dell'elemento nel menu include il numero di riga ed un primo pezzo del testo nella riga. Questo elemento è disponibile solo quando esiste un segnalibro in una riga sopra al cursore. + + + +&Alt;Pagina giùSegnalibri Successivo +Ciò sposterà il cursore all'inizio della prossima riga a cui è associato un segnalibro. La voce nel menu conterrà il numero della riga ed il frammento iniziale del testo della riga. Questa voce è disponibile quando esiste almeno un segnalibro in una delle righe sotto al cursore. + + + + + + + + +Il menu <guimenu +>Strumenti</guimenu +> + + + + +StrumentiManda alla console +Invia il testo selezionato all'emulatore di terminale integrato. Non viene aggiunto alcun carattere di a capo dopo il testo. + + + +StrumentiStrumenti esterni +Questo sottomenu contiene tutti gli strumenti esterni configurati. + + + +Strumenti Modalità sola lettura + +Imposta il documento corrente in Modalità sola lettura. Ciò impedisce qualsiasi inserimento di testo o modifica della formattazione del documento. + + + + +StrumentiTipo di file + +Scegli lo schema per il tipo di file che preferisci per il documento attivo. Questo sovrascrive la modalità del tipo di file globale impostata da Impostazioni Configura &kate;... nella scheda Tipi di file per il solo documento corrente. + + + + +StrumentiEvidenziazione + +Scegli lo schema di evidenziazione che preferisci per il documento attivo. Questo sovrascrive la modalità di evidenziazione globale impostata da Impostazioni Configura &kate;... per il solo documento corrente. + + + + +StrumentiIndentazione + +Scegli lo stile di indentazione che preferisci per il documento attivo. Questo sovrascrive la modalità di indentazione globale impostata da Impostazioni Configura &kate;... per il solo documento corrente. + + + + +StrumentiCodifica + +Puoi sovrascrivere l'impostazione di codifica predefinita in Impostazioni Configura editor... nella scheda Apri/Salva per impostare una differente codifica per il documento corrente. La codifica impostata qui sarà valida unicamente per il documento corrente. + + + + +Strumenti Fine riga + +Scegli lo stile di fine riga che preferisci per il documento attivo. Questo sovrascrive la modalità di indentazione globale impostata da Impostazioni Configura &kate;... per il solo documento corrente. + + + + +StrumentiOrtografia... + + +Lancia il programma di controllo ortografico - un programma dedicato ad aiutare l'utente a scovare e correggere gli errori di scrittura. Facendo clic su questa voce comincerà il controllo e verrà aperta la finestra di dialogo del correttore, attraverso la quale l'utente può controllare il processo. Ci sono quattro impostazioni allineate verticalmente al centro della finestra con alla loro sinistra l'etichetta corrispondente. A partire dall'alto abbiamo: + + + +Parola sconosciuta: +Qui, il controllo ortografico indica la parola in esame. Questo accade quando si incontra una parola non contenuta nel dizionario - un file che contiene una lista di parole corrette ortograficamente che vengono comparate con tutte quelle presenti nell'editor. + + +Sostituisci con: +Se il controllo ha qualche parola simile nel dizionario, la prima viene inclusa qui. L'utente può accettare il suggerimento, scrivere la propria correzione, o scegliere un differente suggerimento dalla prossima casella. + + +Suggerimenti: +Il controllo può inserire qui una lista di possibili sostituzioni per la parola presa in considerazione. Facendo clic su qualsiasi suggerimento questo va a sostituire la parola nella casella Sostituzioni:, in alto. + + +Lingua: +Se hai installato diversi dizionari, qui puoi scegliere quale dizionario/lingua debba essere usato. + + + +Sul lato destro della finestra di dialogo ci sono cinque pulsanti che permettono all'utente di controllare il processo di controllo ortografico. Questi sono: + + + +Aggiungi al dizionario +Premendo questo pulsante si aggiungerà la Parola sbagliata: al dizionario del correttore. Questo significa che in futuro il controllo considererà questa parola ortograficamente corretta. + + +Sostituisci +Questo pulsante ha il compito di sostituire la parola in esame nel documento con la parola nella casella Sostituzioni:. + + +Sostituisci tutto +Questo pulsante fa sì che il controllo rimpiazzi non solo la corrente Parola sconosciuta: ma automaticamente faccia la stessa sostituzione per ogni altra occorrenza di questa Parola scorretta: nel documento. + + +Ignora +Attivando questo pulsante il controllo proseguirà oltre senza applicare cambiamenti. + + +Ignora tutti +Questo pulsante comunica al controllo di ignorare questa Parola sconosciuta ed ignorare altre occorrenze della stessa parola. Ciò si applica solo al controllo corrente. Se il controllo sarà riavviato in un secondo momento, si fermerà su questa stessa parola. + + + +Altri tre pulsanti sono localizzati lungo la base della finestra del controllo ortografico. Essi sono: + + + +Aiuto +Invoca il sistema di aiuto di &kde; con le pagine di aiuto di &kate; caricate (questo documento). + + + +Finito +Questo pulsante ferma il processo di correzione e riporta al documento. + + + +Annulla +Questo pulsante annulla il processo di controllo ortografico, tutte le modifiche sono annullate e si ritornerà al proprio documento. + + + + + + + + +StrumentiCorrezione ortografica (dal cursore)... + +Ciò avvierà il programma di correzione ortografica iniziando dalla posizione corrente del cursore invece che dall'inizio del documento. + + + + +StrumentiControllo ortografico selezione... + +Esegue il controllo ortografico sulla selezione corrente. + + + + + &Ctrl;I StrumentiIndenta + +Aumenta il rientro del paragrafo di un passo. La dimensione del passo dipende dalle impostazioni dell'indentazione. + + + + + &Ctrl;&Shift;I StrumentiAnnulla indentazione + + +Riduce il rientro del paragrafo di un passo. La dimensione del passo dipende dalle impostazioni dell'indentazione. + + + + + +StrumentiPulisci indentazione +Pulisce l'indentazione per la selezione corrente o per la linea su cui si trova al momento il cursore. Pulire l'indentazione garantisce che tutto il tuo testo selezionato segue la modalità di indentazione che hai scelto. + + + + +StrumentiAllinea + +Provoca un riallineamento della riga corrente o delle righe selezionate utilizzando la modalità di indentazione e le impostazioni di indentazione del documento. + + + + + &Ctrl;D Strumenti Commenta +Aggiunge uno spazio all'inizio della linea dove è posizionato il cursore del testo o all'inizio di ciascuna linea selezionata. + + + + + &Ctrl;&Shift;D Strumenti Decommenta +Rimuove uno spazio (se esiste) dall'inizio della riga dove è posizionato il cursore testo o dall'inizio di ciascuna riga selezionata. + + + + &Ctrl;U Strumenti Maiuscolo +Trasforma il testo selezionato o la lettera che segue il cursore in maiuscolo. + + + + &Ctrl;&Shift;U Strumenti Minuscolo +Trasforma il testo selezionato o la lettera che segue il cursore in minuscolo. + + + + &Alt;&Ctrl;U Strumenti Iniziali maiuscole +Trasforma le iniziali in maiuscole nel testo selezionato o nella parola corrente. + + + + &Ctrl;J Strumenti Unisci righe +Unisce le righe selezionate, o la riga corrente e quella successiva con un carattere di spazio come separatore. Gli spazi bianchi iniziali o finali nelle righe unificate saranno rimossi dalle estremità coinvolte. + + + +Strumenti A capo documento +Applica l'a capo statico sull'intero documento. Ciò significa che verrà creata una nuova riga di testo automaticamente quando la riga corrente supererà la lunghezza specificata dall'opzione Colonna a cui andare a capo: nella scheda Modifica in ImpostazioniConfigura editor... + + + + + + + + +Il menu <guimenu +>Sessioni</guimenu +> + +Questo menu contiene voci per l'uso e la gestione delle sessioni di &kate;. Per maggiori informazioni, vedi Uso delle sessioni. + + + + +SessioniNuovo +Crea una nuova sessione vuota. Tutti i file attualmente aperti saranno chiusi. + + + + +SessioniApri... +Apri una sessione esistente. La finestra di scelta della sessione è mostrata per permetterti la scelta. + + + +SessioniApertura rapida +Questo sottomenu permette di aprire una sessione esistente. + + + + +SessioniSalva +Salva la sessione attuale. Se la sessione è anonima, ti verrà chiesto di scegliere un nome. + + + +SessioniSalva con nome... +Salva la sessione attuale con un nuovo nome. Ti verrà chiesto il nome da usare. + + + +SessioniGestisci... +Mostra la finestra di gestione delle sessioni che permette di rinominare e cancellare le sessioni. + + + + + + + + + +Il menu <guimenu +>Impostazioni</guimenu +> + +Il menu Impostazioni permette di cambiare le proprietà della finestra principale, come la visualizzazione delle barre degli strumenti, e fornisce l'accesso alle finestre di configurazione. + + + + + + +ImpostazioniBarre degli strumenti + + +Questo sottomenu elenca le barre di strumenti disponibili, ciascuna voce mostra o nasconde la barra di strumenti associata. + + + + +ImpostazioniModalità a tutto schermo +Attiva o disattiva la modalità a tutto schermo. +Questo comando sarà spostato al menu Finestra in una futura versione di &kate; + + + + + + +Impostazioni Configura le scorciatoie... + + +Mostra la familiare finestra di dialogo per la configurazione delle scorciatoie di &kde;. + + + + + + + +Impostazioni Configura le barre degli strumenti... + + +Mostra la familiare finestra di dialogo per la configurazione delle barre di strumenti di &kde;. + + + + + + +ImpostazioniConfigura &kate;... + + +Apre la finestra di configurazione principale + + + + + + + + +Il menu <guimenu +>Finestra</guimenu +> + + + + + +FinestraNuova finestra + + +Apre una nuova istanza di &kate;. La nuova istanza sarà identica a quella precedente. + + + + + + +&Ctrl;&Shift;L Finestra Dividi verticalmente + + +Divide il riquadro (che può essere l'intera area di lavoro) in due riquadri di dimensione analoga, quello nuovo a destra del precedente. Il riquadro nuovo è focalizzato, e mostra lo stesso documento di quello vecchio. +Vedi anche Lavorare con l'MDI di &kate; + + + + + + +&Ctrl;&Shift;T Finestra Dividi orizzontalmente + + +Divide il riquadro (che può essere l'intera area di lavoro) in due riquadri di dimensione analoga, quello nuovo al di sotto del precedente. Il riquadro nuovo è focalizzato, e mostra lo stesso documento di quello vecchio. +Vedi anche Lavorare con l'MDI di &kate; + + + + + + +&Ctrl;&Shift; R Finestra Chiudi la vista corrente + + +Chiude il riquadro corrente. Se c'è solo un riquadro (l'area di modifica principale), questa voce è disabilitata. Nessun documento viene chiuso con la chiusura di un riquadro – i documenti saranno ancora disponibili nel menu Documenti oltre che nella Lista dei file. Vedi anche Lavorare con l'MDI di &kate; + + + + +F8 FinestraVista successiva +Focalizza la successiva vista del documento, se hai suddiviso l'area di lavoro in più viste. + + + +&Shift;F8 FinestraVista precedente +Focalizza la precedente vista del documento, se hai suddiviso l'area di lavoro in più viste. + + + +FinestraViste accessorie + + + + +FinestraViste accessorie Mostra/Nascondi barre laterali +Attiva o disattiva la barra dei pulsanti della barra laterale. Questo comando non ha effetto sulla visualizzazione dei controlli del contenuto della barra laterale, una barra che sia visibile resterà visibile, e se hai assegnato delle scorciatoie ai comandi sottostanti questi continueranno a funzionare normalmente. + + + + + +FinestraViste accessorieMostra Documenti + + +Attiva o disattiva la visualizzazione della lista dei documenti di &kate; + + + + + + +FinestraViste accessorieMostra/Nascondi Browser del filesystem + + +Mostra o nasconde il navigatore del filesystem di &kate; + + + + + + +FinestraViste accessorieMostra/Nascondi Cerca nel file + + +Mostra o nasconde lo strumento Cerca nel file di &kate;. + + + + + + +FinestraViste accessorie Mostra/Nascondi terminale + + +Commuta la visualizzazione dell'emulatore di terminale integrato. +Quando è attivata la prima volta, il terminale verrà creato. +Quando l'emulatore di terminale è mostrato, verrà messo a fuoco, in modo che tu possa cominciare a scrivere i comandi immediatamente. Se l'opzione Sincronizza l'emulatore di terminale con il documento attivo è abilitata nella pagina Generale della finestra di configurazione principale, la sessione di shell si posizionerà sulla directory del documento corrente, se è un file locale. + + + + + + + + + + + + + + +Il menu <guimenu +>Aiuto</guimenu +> + +A parte le voci del menu Aiuto di &kde; descritti sotto, ci saranno voci di menu per mostrare i manuali per l'utente dei plugin installati. +&help.menu.documentation; + + diff --git a/tde-i18n-it/docs/tdebase/kate/part.docbook b/tde-i18n-it/docs/tdebase/kate/part.docbook new file mode 100644 index 00000000000..fbc3ec459a8 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/part.docbook @@ -0,0 +1,988 @@ + + + +&Anders.Lund; &Anders.Lund.mail; +LuigiToscano
luigi.toscano@tiscali.it
 + + +Lavorare con l'editor &kate; + + + +Panoramica + +L'editor &kate; è l'area modificabile della finestra di &kate;. Questo editor è utilizzato anche da &kwrite; e può essere usato in &konqueror; per mostrare file di testo presenti nel tuo computer o in rete. + +L'editor è costituito dai seguenti componenti: + + + + +L'area di modifica +Qui si trova il testo del documento. + + + +Le barre di scorrimento + +Le barre di scorrimento indicano la posizione della parte visibile del testo del documento e possono essere utilizzate per spostarsi nel documento. L'operazione di trascinamento delle barre di scorrimento non modifica la posizione del cursore di inserimento. +Le barre di scorrimento sono mostrate e nascoste secondo necessità. + + + + +Il bordo per le icone + +Il bordo per le icone è un piccolo pannello alla sinistra dell'editor che mostra una piccola icona in corrispondenza delle righe marcate. +Puoi impostare o rimuovere un segnalibro in una riga visibile facendo clic con il &LMB; nel bordo per le icone in corrispondenza di tale riga. +La visualizzazione del bordo per le icone può essere attivata o disattivata tramite la voce di menu Visualizza Mostra bordo per le icone. + + + + +Il pannello per numeri di riga + +Il pannello per i numeri di riga mostra i numeri di riga di tutte le righe visibili nel documento. +La visualizzazione del pannello per i numeri di riga può essere attivata o disattivata tramite la voce di menu Visualizza Mostra i numeri di riga. + + + + +Il pannello di raggruppamento + +Il pannello di raggruppamento ti consente di richiudere o espandere i blocchi raggruppabili di righe. Le regioni richiudibile vengono determinate in base alle regole specificate nelle definizioni di evidenziazione della sintassi per il documento. + + + + + + +Altri argomenti in questo capitolo: +Navigare nel testo +Lavorare con la selezione +Copiare ed incollare testo +Trovare e sostituire testo +Usare i segnalibri +Andare a capo automaticamente +Usare l'indentazione automatica + + + + + +Navigare nel testo + +Lo spostamento nel testo in &kate; avviene come nella maggior parte degli editor di testo grafici. Puoi spostare il cursore tramite i tasti freccia ed i tasti Pag Su, Pag Giù, Home e Fine in combinazione con i modificatori Ctrl e Shift. Il tasto Shift viene sempre utilizzato per generare una selezione, mentre Ctrl provoca effetti diversi a seconda del tasto: +Per i tasti Su e Giù significa scorrimento invece di spostamento del cursore. +Per i tasti Sinistra e Destra significa saltare parole invece di caratteri. +Per i tasti Freccia Su e Frecci Giù significa spostare il cursore ai limiti della vista invece di navigare nel testo. + +Per i tasti Home e Fine significa spostare il cursore all'inizio o alla fine del documento invece che all'inizio o alla fine della riga. + + + +&kate; mette anche a disposizione un modo per saltare rapidamente alla parentesi corrispondente: posiziona il cursore all'interno di una parentesi e premi Ctrl6 per saltare alla parentesi corrispondente. + +Inoltre puoi utilizzare i segnalibri per saltare rapidamente a delle posizioni che puoi definire a tua scelta. + + + + +Lavorare con la selezione + +Ci sono due metodi di base per selezionare del testo in &kate;: tramite l'uso rispettivamente del mouse e della tastiera. + +Per selezionare usando il mouse, tieni premuto il &LMB; mentre trascini il cursore del mouse dal punto iniziale della selezione fino al punto finale. Il testo sarà selezionato mentre trascini. + +Facendo doppio clic su una parola, questa verrà selezionata. + +Facendo clic triplo su una riga, questa verrà interamente selezionata. + +Se il tasto &Shift; viene tenuto premuto mentre si fa clic, il testo sarà selezionato: + + +Se non è stato ancora selezionato alcun testo, dalla posizione del cursore del testo alla posizione del cursore del mouse. +Se è già attiva una selezione, a partire e includendo tale selezione fino alla posizione del cursore del mouse + + + +Quando selezioni il testo tramite trascinamento del mouse, il testo selezionato viene copiato negli appunti e può essere incollato tramite un clic del pulsante centrale del mouse nell'editor o in qualunque altra applicazione in cui vuoi incollarlo. + + +Per selezionare usando la tastiera, tieni premuto il tasto &Shift; mentre utilizzi i tasti di navigazione (i tasti freccia, Pag Su, Pag Giù, Home e Fine, possibilmente in combinazione con &Ctrl; per estendere il movimento del cursore di testo). + +Vedi anche la sezione Navigare nel testo in questo capitolo. + +Per Copiare la selezione corrente usa la voce di menu Modifica Copia o la scorciatoia di tastiera (quella predefinita è &Ctrl;C). + +Per deselezionare la selezione corrente usa la voce di menu Modifica Deseleziona, o la scorciatoia di tastiera (quella predefinita è &Ctrl;&Shift;A), o fai clic con il &LMB; nell'editor. + + +Usare la selezione a blocchi + +Quando la selezione a blocchi è attiva puoi effettuare selezioni verticali nel testo, cioé selezionare colonne ben definite da righe differenti. Questo è comodo ad esempio per lavorare con righe con dati separati da tabulazioni. + +La selezione a blocchi può essere attivata o disattivata tramite la voce di menu Modifica Modalità selezione a blocchi. La scorciatoia di tastiera predefinita è F4 + + + + + +Usare l'opzione Sovrascrivi selezione + +Se l'opzione Sovrascrivi selezione è attiva, il testo presente nella selezione verrà sostituito se si scrive o si incolla del testo nella selezione. Se non è attiva il nuovo testo verrà aggiunto alla posizione del cursore di testo. + +L'opzione Sovrascrivi selezione è attiva come impostazione predefinita. + +Per cambiare l'impostazione di questa opzione, usa la pagina di selezione della finestra di configurazione. + + + + + +Usare la selezione permanente + +Quando la selezione permanente è attiva, la selezione corrente non verrà annullata se si digitano caratteri o si muove il cursore. Questo vuol dire che puoi spostare il cursore dalla selezione e continuare a digitare. + +La selezione permanente è disattivata come impostazione predefinita. + +La selezione permanente può essere abilitata tramite la pagina di selezione della finestra di configurazione. + + +Se la selezione permanente e Sovrascrivi selezione sono entrambe attive, digitare o incollare del testo quando il cursore di testo è all'interno della selezione farà sì che questa venga annullata e il testo contenuto sostituito. + + + + + + + + +Copiare ed incollare testo + +Per copiare del testo, selezionalo ed usa la voce di menu Modifica Copia.Inoltre, se si seleziona del testo con il mouse, questo verrà copiato nella selezione di X. + +Per incollare il testo presente negli appunti, usa la voce di menu ModificaIncolla. + +Inoltre il testo selezionato tramite il mouse può essere incollato facendo clic con il pulsante centrale del mouse nella posizione desiderata. + + +Se utilizzi l'ambiente desktop &kde;, puoi riprendere da una qualsiasi applicazione il testo copiato precedentemente tramite l'icona di &klipper; presente nel vassoio di sistema di &kicker;. + + + + + +Trovare e sostituire testo + + +Le finestre di dialogo <guilabel +>Trova testo</guilabel +> e <guilabel +>Sostituisci testo</guilabel +> + + +Le finestre di dialogo Trova e Sostituisci testo sono molto simili, con la differenza che quella di sostituzione dà la possibilità di inserire la nuova stringa insieme ad alcune opzioni aggiuntive. + +Le finestre di dialogo presentano le seguenti opzioni comuni: + + + + +Testo da trovare +Qui va inserita la stringa di ricerca. L'interpretazione della stringa dipende da alcune delle opzioni descritte più avanti. + + + +Espressione regolare + +Se marcata, la stringa da cercare viene interpretata come un'espressione regolare. Verrà attivato un pulsante per lanciare uno strumento grafico per creare o modificare l'espressione. +Vedi la sezione Espressioni regolari per maggiori informazioni. + + + + +Ignora maiuscole/minuscole + +Se attivo, la ricerca non terrà conto della distinzione tra maiuscole e minuscole. + + + + +Solo parole intere + +Se marcata, la ricerca avrà successo solo se c'è un delimitatore di parola ad entrambi gli estremi della stringa trovata, intendendo con questo non un carattere alfanumerico - né un carattere visualizzabile o un fine riga. + + + + +Dal cursore + +Se marcata, la ricerca partirà dalla posizione del cursore, altrimenti partirà dall'inizio della prima riga del documento. + + + + +Trova all'indietro + +Se marcata, la ricerca controllerà la prima corrispondenza sopra il punto di partenza, sia esso la posizione del cursore o l'inizio del documento se l'opzione Dall'inizio è attiva. + + + + + +La finestra di dialogo Sostituisci testo mette a disposizione alcune opzioni addizionali: + + + + +Sostituisci con +Qui va inserita la stringa di sostituzione. + + + +Testo selezionato + +Questa opzione è disabilitata se non è stato selezionato alcun testo o se l'opzione Chiedi prima di sostituire è attiva. Se marcata, tutte le corrispondenze della stringa di ricerca con il testo selezionato verranno rimpiazzate dalla stringa di sostituzione. + + + + +Chiedi prima di sostituire +Se marcata, una piccola finestra di dialogo ti chiederà cosa fare ogni volta che viene trovata una corrispondenza. Mette a disposizione le seguenti opzioni: + + +Sì +Attiva questa per rimpiazzare la corrispondenza corrente (selezionata nell'editor). + + + +No +Attivare per saltare la corrispondenza corrente e cercarne un'altra. + + + +Tutti +Attivare per non chiedere ulteriormente e sostituire tutte le corrispondenze. + + + +Chiudi +Attiva questa per saltare la corrispondenza corrente e terminare la ricerca. + + + + + + + + + + +Al momento non è possibile impostare una corrispondenza minimale quando si utilizza un'espressione regolare per cercare. Questa funzione verrà aggiunta nelle versioni future di &kate; + + + + + +Trovare del testo + +Per trovare del testo, lancia la finestra di dialogo Trova testo con &Ctrl;F oppure tramite la voce di menu Modifica Trova..., inserisci la stringa di ricerca, imposta le opzioni come preferisci e premi Ok. Se la ricerca è partita dalla posizione del cursore e non è stata trovata alcuna corrispondenza prima della fine del documento (o dell'inizio se è una ricerca inversa), ti verrà richiesto se ricercare da capo (o dal fondo). + +Se viene trovata una corrispondenza, questa verrà selezionata e la finestra di dialogo Trova testo nascosta, ma niente paura, è facile trovare ulteriori corrispondenze: + +Per cercare la successiva occorrenza nella direzione impostata per la ricerca, utilizza il comando Modifica Trova successivo o premi F3. + +Per cercare la successiva occorrenza nella direzione opposta, utilizza il comando Modifica Trova precedente o premi &Shift;F3. + +Se non è stata trovata alcuna corrispondenza prima della fine del documento (o dell'inizio se è una ricerca inversa), ti verrà richiesto se ricercare da capo (o dal fondo). + + + + +Sostituire il testo + +Per sostituire del testo, lancia la finestra di dialogo Sostituisci testo tramite il comando Modifica Sostituisci... oppure tramite la scorciatoia di tastiera &Ctrl;R, inserisci la stringa di ricerca e opzionalmente una stringa di sostituzione (se questa è vuota, il testo di ogni corrispondenza sarà cancellato), imposta le opzioni come preferisci e premi Ok. + + +Se usi un'espressione regolare per trovare il testo da sostituire puoi utilizzare i riferimenti all'indietro per riutilizzare il testo catturato tra parentesi nel sottomodello dell'espressione. +Vedi per maggiori informazioni sull'argomento. + + +Puoi usare i comandi find, replace e ifind (ricerca incrementale) dalla riga di comando. + + + + + + + +Usare i segnalibri + +I segnalibri ti consentono di marcare alcune riga per poterle ritrovare successivamente in modo semplice. + +Puoi impostare o rimuovere un segnalibro in una riga in due modi: + + + +spostando il cursore di inserimento nella riga e usando il comando SegnalibriMetti segnalibro (&Ctrl;B). + + +facendo clic sul bordo per le icone in corrispondenza della riga. + + + + +I segnalibri sono raggiungibili dal menu Segnalibri.Ognuno di essi è disponibile come voce di menu, etichettata con il numero di riga a cui è associato il segnalibro e i primi caratteri del testo di tale riga. Per spostare il cursore di inserimento all'inizio di una riga con segnalibro, apri il menu e seleziona il segnalibro. + +Per spostarti rapidamente tra i segnalibri o andare al segnalibro successivo/precedente, usa rispettivamente le voci di menu SegnalibriSuccessivo (Ctrl Pag Giù) o SegnalibriPrecedente (CtrlPag Su ). + + + + + +Andare a capo automaticamente + +Questa funzione ti consente di formattare il testo in modo semplice: il testo andrà a capo automaticamente in modo che nessuna riga possa contenere più di un determinato numero di caratteri, a meno che non ci sia una stringa più lunga senza spazi. + +Per attivarla/disattivarla, marca/smarca la casella A capo automatico nella pagina di modifica della finestra di configurazione. + +Per impostare la lunghezza massima di una riga (numero massimo di caratteri per riga) usa l'opzione Colonna a cui andare a capo: nella pagina di modifica della finestra di configurazione. + +Se attivo ha i seguenti effetti: +Mentre digiti l'editor automaticamente interrompe la riga dopo l'ultimo carattere separatore presente in posizione precedente al raggiungimento della dimensione massima per la riga. +In fase di caricamento di un documento, l'editor manderà a capo il testo in modo analogo, facendo sì che non ci siano righe più lunghe della massima dimensione consentita se contengono dei caratteri separatori che lo consentono. + + + + +Non c'è modo al momento di impostare l'a capo automatico per tipo di documento, e neppure di abilitarlo o disabilitarlo a livello di documento. Questo problema sarà risolto in una futura versione di &kate; + + + + +Usare l'indentazione automatica + +Il componente editor di &kate; supporta differenti modalità di autoindentazione progettate per differenti formati di testo. Puoi scegliere tra le modalità disponibili tramite la voce di menu StrumentiIndentazione. Il modulo di autoindentazione mette a disposizione la funzione StrumentiAllinea che ricalcola l'indentazione della riga selezionata o di quella corrente. In questo modo puoi indentare nuovamente il documento selezionando tutto il testo e attivando tale azione. + +Tutte le modalità di indentazione usano le impostazioni relative all'indentazione per il documento corrente. + +Puoi impostare tutti i tipi di variabili di configurazione, comprese quelle relative all'indentazione, tramite le variabili dei documenti e i tipi di file. + + + +Modalità di autoindentazione disponibili + + +Nessuno +Questa modalità disabilita completamente l'indentazione. + + + + +Normale +Questa modalità si limita a mantenere l'indentazione simile a quella della riga precedente con contenuto diverso da spazi e separatori. Puoi combinarne l'utilizzo con quello delle azioni di indentazione e di rimozione dell'indentazione per indentare come meglio credi. + + +Stile C +Un sistema d'indentazione per il linguaggio C ed altri linguaggi analoghi come C++, C#, Java, JavaScript e così via. Questo sistema non funziona per linguaggi di scripting come Perl o PHP. + + + +Stile C SS +Un sistema d'indentazione alternativo per il linguaggio C ed altri linguaggi simili, con gli stessi vincoli. + + + +Stile Python +Un sistema d'indentazione specifico per il linguaggio di scripting Python. + + + +XML +Un indentatore automatico molto interessante per XML. Per quanto sia allettante, non cercare di utilizzarlo con dialetti HTML diversi da XHTML, perché fallisce con i tag HTML vecchio stile (tag aperti come ad esempio <br>) + + + +Indentatore variabile + + + +L'indentatore variabile è sperimentale, e potrebbe cambiare il suo comportamento o sparire in una prossima versione. + + +L'indentatore variabile è speciale nel senso che può essere configurato tramite le variabili del documento (o la configurazione del tipo di file). Vengono lette le seguenti variabili: + +var-indent-indent-after + +Un'espressione regolare che fa sì che una riga sia indentata di una unità, se la prima riga tra le successive non composta di soli spazi bianchi e separatori corrisponde. var-indent-indent: Un'espressione regolare che fa sì che la riga che corrisponde sia indentata di una unità. + + + + + +var-indent-unindent + +Un'espressione regolare che fa sì che venga tolta l'indentazione di una unità dalla riga che corrisponde. + + + + +var-indent-triggerchars + +Una lista di caratteri che, se digitati, causa il ricalcolo immediato dell'indentazione. + + + + +var-indent-handle-couples + +Una lista di insiemi di parentesi da gestire. Ogni combinazione di parentesi tonde, quadre o graffe. Ogni tipo di insieme è gestito nel seguente modo: se ve ne sono istanze aperte non corrispondenti nella riga precedente, viene aggiunta un'unità di indentazione; se vi sono delle istanze chiuse non corrispondenti nella riga corrente, viene rimossa un'unità di indentazione. + + + + +var-indent-couple-attribute + +Quando vengono cercate coppie aperte/chiuse non corrispondenti, sono considerati solo i caratteri con questo attributo. Il valore deve essere il nome dell'attributo del file di sintassi xml, ad esempio "Symbol". Se non è specificato, verrà usato l'attributo 0 (normalmente 'Normal Text'). + + + + + + + + + + + + + diff --git a/tde-i18n-it/docs/tdebase/kate/plugins.docbook b/tde-i18n-it/docs/tdebase/kate/plugins.docbook new file mode 100644 index 00000000000..67de00c2bf8 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/plugins.docbook @@ -0,0 +1,39 @@ + + + + +&Anders.Lund; &Anders.Lund.mail; +Nicola Ruggero
nicola@nxnt.org
Traduzione della documentazione. + + + +Lavorare con i plugin + +Kate usa due forme diverse di plugin: i plugin per l'applicazione &kate; e i plugin per il componente dell'editor di &kate;. Quest'ultimi sono disponibili per qualsiasi applicazione faccia uso del componente dell'editor, come KDevelop, Quanta, Kile, Kwrite e molte altre. I plug per l'applicazione invece sono specifici per l'applicazione &kate;. + +Puoi abilitare entrambi i tipi di plugin nella finestra di configurazione, che fornisce inoltre l'accesso alle opzioni di configurazione aggiuntive per i plugin che le richiedano. + +Ci sono vari plugin per diversi scopi disponibili nel modulo tdeaddons e puoi trovarne degli altri cercando nel web. Alcuni di questi sono distribuiti assieme al componente dell'editor. Ad esempio: il completamento parole, i segnalibri automatici, l'inserimento file, i sinonimi, il controllo ortografico e la ricerca incrementale. + + diff --git a/tde-i18n-it/docs/tdebase/kate/regular-expressions.docbook b/tde-i18n-it/docs/tdebase/kate/regular-expressions.docbook new file mode 100644 index 00000000000..df033ac45b8 --- /dev/null +++ b/tde-i18n-it/docs/tdebase/kate/regular-expressions.docbook @@ -0,0 +1,1216 @@ + + + +&Anders.Lund; &Anders.Lund.mail; +LucianoMontanaro
mikelima@cirulla.net
Traduzione + + + +Le espressioni regolari + +Questa appendice contiene un'essenziale introduzione al mondo delle espressioni regolari. Documenta le espressioni regolari nella froma disponibile in &kate;, che non è compatibile con quella di perl né con quella disponibile, per esempio, in grep. + + + +Introduzione + +Le espressioni regolari forniscono un modo di descrivere il contenuto richiesto di una stringa di testo in modo comprensibile dal software, al fine di verificare se una sequenza di testo corrisponde al modello fornito, e, nel caso di applicazioni avanzate, permettono di memorizzare parti del testo corrispondenti. + +Un esempio: diciamo che vuoi cercare nel testo tutti i paragrafi che iniziano per uno dei nomi Henrik o Pernille seguito da qualche forma del verbo say. + +Con una ricerca normale, cominceresti con la ricerca del primo nome, Henrik, magari seguito da sa, così: Henrik sa, ed esaminando le corrispondenze, dovresti scartare tutte quelle in cui non si trovano all'inizio di un paragrafo, oltre a quelle in cui le parole che iniziano per sa non sono né says né said. E tutto ciò dovrà essere ripetuto con l'altro nome... + +Con le espressioni regolari questo compito può essere svolto con una sola ricerca, e con una precisione più elevata. + +Per farlo, le espressioni regolari definiscono regole per esprimere nel dettaglio una generalizzazione di una stringa da confrontare. Il nostro esempio, che potremmo esprimere in questo modo: Una riga che inizia con Henrik o Pernille (forse preceduti da fino a quattro caratteri di spazio o tabulazione) seguiti da un carattere di spaziatura seguito da sa e poi o ys o id, può essere espresso con la seguente espressione regolare: ^[ \t]{0,4}(Henrik|Pernille) sa(ys|id) + +L'esempio appena introdotto dimostra i quattro concetti alla base delle espressioni regolari moderne, cioè: + + +I modelli +Le asserzioni +I quantificatori +I riferimenti all'indietro + + +Il carattere di accento circonflesso (^) che appare all'inizio dell'espressione è un'asserzione, che è vera solo se il resto della stringa da confrontare è all'inizio di una riga. + +Le stringhe [ \t] e (Henrik|Pernille) sa(ys|id) sono modelli. Il primo è una classe di caratteri che corrisponde un carattere di spazio o di tabulazione (orizzontale); l'altro modello contiene prima un sotto-modello che corrisponde a Henrik o Pernille, poi un gruppo di caratteri che corrisponde letteralmente a sa ed infine un sotto-modello che corrisponde a ys o id + +La sequenza {0,4} è un quantificatore che indica da zero a quattro ripetizioni dell'espressione precedente. + +Poiché il software per le espressioni regolari che gestisce il concetto di riferimento all'indietro salva l'intera sequenza di caratteri che corrisponde al modello, oltre ai sottomodelli racchiusi fra parentesi, se ci fosse modo di accedere a tali riferimenti, potremmo mettere le mani sull'intero testo corrispondente al modello (in caso di ricerca di un'espressione regolare in un editor di testo, la corrispondenza è indicata come selezionata) oppure il nome trovato, o l'ultima parte del verbo. + +Nell'insieme, l'espressione corrisponderà a quello che vogliamo, e solo a quello. + +Le sezioni seguenti descriveranno in dettaglio come costruire e usare i modelli, le classi di caratteri, le asserzioni, i quantificatori ed i riferimenti all'indietro, e la sezione finale fornirà qualche utile esempio. + + + + + +I modelli + +I modelli consistono di sequenze di caratteri letterali e di classi di caratteri. I modelli possono contenere sotto-modelli, che sono modelli racchiusi fra parentesi. + + +I caratteri speciali + +Nei modelli così come nelle classi di caratteri, alcuni caratteri hanno un significato speciale. Perché corrispondano letteralmente ad uno di questi caratteri bisogna indicarne l'interpretazione letterale al software di gestione delle espressioni regolari. + +Ciò si fa inserendo come prefisso del carattere una barra inversa (\). + + +Il software di gestione delle espressioni regolari ignora in silenzio l'uso di un carattere di escape prima di un carattere senza particolari significati, quindi se viene anteposto, ad esempio, a j (\j) non è dannoso. Se hai dei dubbi sul fatto che un dato carattere possa avere significati speciali, puoi anteporvi il carattere di escape per sicurezza. + +Per inserire un carattere di barra inversa devi ripetere il carattere stesso, scrivendo \\. + + + + +Classi di caratteri e abbreviazioni + +Una classe di caratteri è un'espressione regolare che corrisponde ad uno di un gruppo di caratteri particolare. Nelle espressioni regolari, le classi di caratteri sono definite inserendo i caratteri legali per la classe fra parentesi quadre, [], o usando una delle classi predefinite descritte più avanti. + +Classi di caratteri semplici contengono solo uno o più caratteri letterali, come ad esempio [abc] (che corrisponde ad una delle lettere a, b o c) o [0123456789] (che corrisponde ad una delle cifre decimali). + +Poiché le lettere e i numeri hanno un ordine logico, puoi abbreviare le definizioni delle classi che li contengono specificando degli intervalli: [a-c] è equivalente a [abc] e [0-9] equivale a scrivere [0123456789]. Sono ammesse anche le combinazioni di questi costrutti, ad esempio, [a-fynot1-38] corrisponde ad un carattere fra a, b, c, d, e, f, y, n, o, t, 1, 2,3 e 8. + +Poiché le lettere maiuscole vengono distinte da quelle minuscole, per creare una classe di caratteri che corrisponda ad a o b senza distinguere fra maiuscole e minuscole devi scrivere [aAbB]. + +È anche possibile creare una classe di caratteri negativa, che corrisponde dove un qualunque carattere tranne quelli elencati è presente. Per far ciò inserisci un carattere di accento circonflesso ^ all'inizio della classe: + +[^abc] corrisponderà ad un carattere qualsiasi che non sia a, b o c. + +Oltre ai caratteri letterali sono definite alcune abbreviazioni che rendono la vita un po' più semplice: + + +\a +Questo corrisponde al carattere campanella ASCII (BEL, 0x07). + + + +\f +Corrisponde al carattere di avanzamento carta ASCII (FF, 0x0C). + + + +\n +Corrisponde al carattere ASCII di avanzamento riga (LF, 0x0A, newline in Unix). + + + +\r +Corrisponde al carattere ASCII ritorno carrello (CR, 0x0D). + + + +\t +Corrisponde ad un carattere ASCII di tabulazione orizzontale (HT, 0x09). + + + +\v +Corrisponde ad un carattere ASCII di tabulazione verticale (VT, 0x0B). + + +\xhhhh + +Questo corrisponde ad un carattere Unicode che ha la rappresentazione esadecimale hhhh (tra 0x0000 e 0xFFFF). \Oooo (&ie; \zero ooo) corrisponde al carattere ASCII/Latin-1 rappresentato dal numero ottale 000 (compreso tra 0 e 0377). + + + +. (punto) +Corrisponde ad un carattere qualsiasi (anche ad un nuova riga). + + + +\d +Questo corrisponde ad una cifra decimale. È lo stesso di [0-9] + + + +\D +Corrisponde ad un carattere non numerico. Equivale a [^0-9] o [^\d] + + + +\s +Corrisponde ad un carattere di spaziatura. Equivale a [ \t\n\r] + + + +\S +Corrisponde ad un carattere che non è di spaziatura. Equivale a [^ \t\n\r] ed è uguale a [^\s] + + + +\w +Corrisponde ad un carattere di parola - in questo caso a qualsiasi lettera o numero. Nota che il carattere di sottolineatura (_) non viene considerato un carattere di parola, come succede nelle espressioni regolari di perl. È uguale a [a-zA-Z0-9] + + + +\W +Corrisponde ad un carattere di non-parola - qualsiasi carattere che non sia una lettera o un numero. Equivale a [^a-zA-Z0-9] o a [^\w] + + + + + + + +Le classi abbreviate possono essere inserite all'interno di classi personalizzate, ad esempio per richiedere la corrispondenza di n carattere di parola, di uno spazio o di un punto, puoi scrivere [\w \.] + + La notazione POSIX per le classi, [:<nomeclasse>] non è al momento supportata. + + +Caratteri con un significato speciale all'interno delle classi di caratteri + +I seguenti caratteri hanno un significato particolare all'interno del costrutto [] delle classi di caratteri, e devono essere preceduti dal carattere di escape per essere inclusi letteralmente in una classe: + + + +] +Termina la classe di caratteri. Deve essere preceduto dal carattere di escape a meno che non sia esattamente il primo della classe (può seguire un carattere ^, che indica la negazione della classe) + + +^ (simbolo di accento circonflesso) +Denota una classe negativa, se è il primo carattere. Deve essere preceduto dal carattere di escape se deve corrispondere letteralmente se è il primo carattere della classe. + + +- (trattino) +Denota un intervallo logico di caratteri. Deve sempre essere preceduto dal carattere di escape per essere interpretato alla lettera in una classe di caratteri. + + +\ (barra inversa) +Il carattere di escape. Deve sempre essere raddoppiato per essere interpretato letteralmente. + + + + + + + + + + +Alternative: corrispondenza del tipo <quote +>uno fra</quote +> + +Se vuoi controllare se il testo corrisponde ad uno fra una serie di modelli alternativi, puoi separare ciascuna alternativa con un carattere | (barra verticale). + +Ad esempio, per trovare uno fra John ed Harry, devi usare l'espressione John|Harry. + + + + + +I sotto-modelli + +I sotto-modelli sono modelli racchiusi fra parentesi, ed hanno molti usi nel mondo delle espressioni regolari. + + + +Specificare delle alternative + +Puoi usare un sotto-modello per raggruppare un insieme di alternative all'interno di un modello più grande. Le alternative sono separate dal carattere | (barra verticale). + +Ad esempio per cercare una parola fra int, float e double, puoi usare il modello int|float|double. Se vuoi trovare la parole solo se è seguita da un po' di spazi e delle lettere, inserisci le alternative in un sotto-modello: (int|float|double)\s+\w+. + + + + + +Cattura del testo corrispondente (riferimenti all'indietro) + +Se vuoi usare un riferimento all'indietro, usa un sotto-modello per fare in modo che la sezione che ti interessa del modello sia ricordata. + +Per esempio, se vuoi trovare due ripetizioni della stessa parola separate da una virgola ed eventualmente da qualche spazio bianco, puoi scrivere (\w+),\s*\1. Il sottomodello \w+ troverà una sequenza di caratteri di parola, e l'intera espressione corrisponderà se gli stessi caratteri saranno seguiti da una virgola, zero o più caratteri di spaziatura, e da un'identica sequenza di caratteri di parola (La stringa \1 si riferisce al primo sottomodello racchiuso fra parentesi). + + + + + + +Asserzioni di lookahead + +Un'asserzione di lookahead è un sotto-modello che inizia con ?= o ?!. + +Per esempio per trovare la stringa letterale Bill ma solo se non è seguita da Gates, puoi usare questa espressione: Bill(?! Gates). Verrà trovato Bill Clinton ed anche Billy the kid, ma verranno ignorate silenziosamente le altre corrispondenze.) + +I sotto-modelli usati per le asserzioni non sono catturati. + +Vedi anche Le asserzioni + + + + + + +Caratteri con un significato speciali in un modello + +I seguenti caratteri hanno un significato all'interno di un modello, e devi farli precedere da un carattere di escape se devi controllarne la presenza letterale: + + +\ (barra inversa) +Il carattere di escape. + + + +^ (simbolo di accento circonflesso) +Asserisce l'inizio della stringa. + + + +$ +Asserisce la fine della stringa. + + + +() (parentesi aperta e chiusa) +Denotano un sotto-modello. + + + +{} (parentesi graffe aperta e chiusa) +Denotano quantificatori numerici. + + + +[] (parentesi quadre aperta e chiusa) +Denotano classi di caratteri. + + + +| (barra verticale) +OR logico. Separa le alternative. + + + ++ (segno più) +Quantificatore, uno o più. + + + +* (asterisco) +Quantificatore, zero o più. + + + +? (punto interrogativo) +Carattere facoltativo. Può essere interpretato come un quantificatore, zero o uno. + + + + + + + + + + + +Quantificatori + +I quantificatori permettono a un'espressione regolare di corrispondere ad un numero specificato di caratteri o di caratteri di una classe, o di sotto-modelli. + +I quantificatori sono racchiusi da parentesi graffe ({ e }) ed hanno la forma generale {[ripetizioni-minime][,[ripetizioni-massime]]} + +L'uso è spiegato meglio con degli esempi: + + +{1} +Esattamente una ripetizione + + + +{0,1} +Zero o una ripetizione + + + +{,1} +La stessa cosa, ma con meno lavoro... + + + +{5,10} +Almeno cinque ripetizioni, ma meno di dieci. + + + +{5,} +Almeno cinque ripetizioni, nessun massimo. + + + + + + +Inoltre esistono alcune abbreviazioni: + + +* (asterisco) +simile a {0,}, trova un numero qualsiasi di ripetizioni. + + + ++ (segno più) +simile a {1,}, almeno una presenza. + + + +? (punto interrogativo) +simile a {0,1}, presente al massimo una volta. + + + + + + + + +Ingordigia + +Quando si usano quantificatori senza massimo, le espressioni regolari cercano normalmente di adattarsi all'estensione più lunga di caratteri della stringa esaminata, comportamento normalmente noto come ingordigia. + +IL software per le espressioni regolari moderno fornisce dei metodi per eliminare l'ingordigia, sebbene in un ambiente grafico dipende dall'interfaccia il metodo di accesso a questa funzione. Per esempio una finestra di ricerca che permette l'uso di espressioni regolari, potrebbe avere una casella marcata Corrispondenza minimale, e dovrebbe indicare se l'ingordigia è il comportamento predefinito. + + + + +Esempi in contesto + +Ecco alcuni esempi che usano quantificatori + + + + +^\d{4,5}\s +Corrisponde ai numeri in 1234 vai e 12345 ora, ma non a 567 undici né a 223459 qualcosa + + + +\s+ +Corrisponde ad uno o più caratteri di spaziatura + + + +(bla){1,} +Corrisponde a tutta la stringa blablabla e a bla in blasone o cablato + + + +/?> +Corrisponde a /> in <closeditem/> ed anche a > in <openitem>. + + + + + + + + + +Le asserzioni + +Le asserzioni permettono ad un'espressione regolare di corrispondere solo a certe condizioni. + +Un'asserzione non corrisponde necessariamente a un carattere, piuttosto impone delle restrizioni sulle condizioni della possibile corrispondenza prima di riconoscerla. Ad esempio l'asserzione confine parola non cerca di trovare un carattere non-parola di fianco ad uno di parola, si assicura solo che non ci sia un carattere parola. Quindi l'asserzione corrisponde dove non c'è un carattere, &ie; alla fine della stringa in esame. + +Alcune asserzioni hanno effettivamente modelli da confrontare, ma la parte di stringa a cui corrispondono non faranno parte del risultato del confronto dell'espressione regolare intera. + +Le espressioni regolari qui documentate permettono di usare le seguenti asserzioni: + + +^ (caret: inizio stringa) +Corrisponde all'inizio della stringa vagliata. L'espressione ^Peter corrisponderà a Peter Nella stringa Peter, hey! ma non in Hey, Peter! + + + +$ (fine della stringa) +Corrisponde alla fine della stringa vagliata. + +L'espressione you\?$ corrisponde all'ultimo you della frase You didn't do that, did you? man non a You didn't do that, right? + + + + + +\b (confine parola) +Corrisponde se c'è un carattere di parola su un lato ed un carattere che non fa parte di una parola sull'altro. +È utile per trovare le estremità di una parola. Come esempio, all'espressione \bin\b corrisponde l'in in He came in through the window, ma non l'in di window. + + + + +\B (non confine parola) +Corrisponde a tutto quello che non corrisponde a \b. +Ciò significa che corrisponderà ad esempio all'interno di parole: L'espressione \Bin\B corrisponde in window ma non in integer o in I'm in love. + + + + +(?=MODELLO) (Lookahead positivo) +Un'asserzione di lookahead controlla la parte della stringa che segue una potenziale corrispondenza. Il lookahead positivo impedirà che la stringa corrisponda se il testo che segue non corrisponde al MODELLO dell'asserzione, ma il testo a cui corrisponde non sarà incluso nel risultato. +L'espressione handy(?=\w) corrisponderà a handy in handyman ma non in That came in handy! + + + + +(?!MODELLO) (Lookahead negativo) + +Il lookahead negativo impedisce una potenziale corrispondenza se la parte seguente della stringa in esame non corrisponde al MODELLO. +L'espressione const \w+\b(?!\s*&) corrisponde a const char nella stringa const char* foo mentre non corrisponde a const QString in const QString& bar perché & corrisponde al modello dell'asserzione di lookahead negativo. + + + + + + + + + + + + -- cgit v1.2.1