Fix typo in BUILD deps for //wmaker:keybind.

Create //wmaker:notifications and //wmaker:appearance_settings.

.gitignore

@@ -138,3 +138,11 @@ WPrefs.app/WPrefs.desktop
 *~
 
 .pc
+
+# Bazel's build symlinks shouldn't be committed.
+bazel-bazel
+bazel-bin
+bazel-out
+bazel-testlogs
+# Don't commit lockfile until things are more stable.
+MODULE.bazel.lock

bazel/MODULE.bazel

@@ -0,0 +1,6 @@
+###############################################################################
+# Bazel now uses Bzlmod by default to manage external dependencies.
+# Please consider migrating your external dependencies from WORKSPACE to MODULE.bazel.
+#
+# For more details, please check https://github.com/bazelbuild/bazel/issues/18958
+###############################################################################

bazel/WINGs/BUGS

@@ -0,0 +1,3 @@
+- filepanel does not reread / . If you add new files in / they will not be
+  visible until the program is restarted. Closing and reopening the file
+  panel does not help.

bazel/WINGs/BUILD.bazel

@@ -0,0 +1,86 @@
+cc_library(
+    name = "WINGs",
+    copts = [
+        "-DRESOURCE_PATH=\\\"Resources\\\"",
+        "-D_GNU_SOURCE",
+        "-DHAVE_BSD_STRING_H",
+    ],
+    data = glob(['Resources/*']),
+    srcs = [
+        "array.c",
+        "bagtree.c",
+	    "configuration.c",
+        "data.c",
+	    "dragcommon.c",
+	    "dragdestination.c",
+	    "dragsource.c",
+        "error.c",
+        "findfile.c",
+        "handlers.c",
+        "hashtable.c",
+        "memory.c",
+        "menuparser.c",
+        "menuparser_macros.c",
+        "misc.c",
+        "notification.c",
+        "proplist.c",
+	    "selection.c",
+        "string.c",
+        "tree.c",
+        "userdefaults.c",
+        "usleep.c",
+        "wapplication.c",
+	    "wappresource.c",
+	    "wballoon.c",
+	    "wbox.c",
+	    "wbrowser.c",
+	    "wbutton.c",
+	    "wcolor.c",
+	    "wcolorpanel.c",
+	    "wcolorwell.c",
+	    "wevent.c",
+	    "wfilepanel.c",
+	    "wfont.c",
+	    "wfontpanel.c",
+	    "wframe.c",
+	    "widgets.c",
+	    "winputmethod.c",
+	    "wlabel.c",
+	    "wlist.c",
+	    "wmenuitem.c",
+	    "wmisc.c",
+	    "wpanel.c",
+	    "wpixmap.c",
+	    "wpopupbutton.c",
+	    "wprogressindicator.c",
+	    "wruler.c",
+	    "wscroller.c",
+	    "wscrollview.c",
+	    "wslider.c",
+	    "wsplitview.c",
+	    "wtabview.c",
+	    "wtext.c",
+	    "wtextfield.c",
+	    "wview.c",
+	    "wwindow.c",
+    ],
+    hdrs = [
+        "menuparser.h",
+        "userdefaults.h",
+        "rgb.h",
+	    "wconfig.h",
+        "WINGs.h",
+        "WINGsP.h",
+        "WUtil.h",
+    ],
+    deps = [
+        "//config",
+        "//wmaker:gnustep_compat",
+        "//wrlib",
+        "@freetype2//:lib",
+        "@libbsd//:lib",
+        "@pango//:lib",
+        "@pangoxft//:lib",
+    ],
+    visibility = ["//visibility:public"],
+)

bazel/WINGs/ChangeLog

@@ -0,0 +1,659 @@
+Changes since wmaker 0.96.0:
+............................
+
+- added W_KeycodeToKeysym to replace XKeycodeToKeysym/XkbKeycodeToKeysym calls
+
+
+Changes since wmaker 0.92.0:
+............................
+
+- updated the XDND code in to work with GDK based applications.
+  WINGs based applications should now work with both KDE and GNOME
+  applications (Sylvain Reynal <sreynal@nerim.net>)
+- better check for the XDND protocol version when interoperating with other
+  applications. As it seems xdnd version 3 (which WINGs supports) and newer
+  are not backward compatible with xdnd version 1 and 2. This is why WINGs
+  applications cannot interoperate with GNUstep applications (which uses
+  xdnd version 2). Xdnd version 4 and 5 are backwards compatible with
+  version 3 though. (Sylvain Reynal <sreynal@nerim.net>)
+- removed dependency on rgb.txt from X11 and issues with locating it on the
+  filesystem for different systems/distributions.
+- Removed dependency on rgb.txt (from X11) and issues with locating it on the
+  filesystem for different systems/distributions.
+
+
+Changes since wmaker 0.80.1:
+............................
+
+- Added WMSetConnectionShutdownOnClose()
+- Added an extra member to the ConnectionDelegate: canResumeSending
+  see NEWS for details.
+- WMDrawString() and WMDrawImageString() now take WMColor instead of GC as
+  arguments. WMDrawImageString() receives 2 colors (text & background).
+  This is to allow easy extension for Xft/Xrender and hide X low level details
+  Read NEWS for details since this will break backward compatibility.
+- Added alpha channel to WMColor. 2 new functions also:
+  WMCreateRGBAColor() and WMSetColorAlpha()
+- Miscelaneous code cleanups in wtext.c
+- Added Xft2 support in WINGs (for drawing antialiased fonts with transparency).
+- New options in WMGLOBAL: AntialiasedText. Check NEWS for details.
+- Fixed some improper calls to snprintf in wfont.c
+- Added double buffering when drawing a WMFrame title with an antialiased font
+  to avoid flickering.
+- Added double buffering when drawing WMList items to avoid flickering.
+  Double buffering for list also works for user drawn lists. Read NEWS for
+  details and incompatibilities introduced by this change.
+- Added WMGetColorAlpha(WMColor *color)
+- Better outline when drawing balloons.
+- Added WMCreateFontWithAttributes()
+- You can now pass "SystemFont", "BoldSystemFont", "SystemFont-##" or
+  "BoldSystemFont-##", with ## being the font size to any font creating
+  function to create a font with the (bold) system font font specification.
+- Added WMCopyFontWithChanges(). This is a more generic and powerful function
+  meant to replaces the obsoleted WMEmphasizeFont(), WMNormalizeFont(),
+  WMStrenghtenFont() and the other similar functions. To get the same effect
+  you pass some predefined structs to it: WFANormal, WFABold, WFAEmphasized,
+  etc which are declared in WINGs.h).
+- Fixed a bug with empty frame titles (Alexey Voinov <voins@voins.program.ru>)
+- Added WMGetWidgetBackgroundColor()
+- Code cleanup in wtext.c
+- Fixed a memory leak in wfontpanel.c
+- Fixed WMGetTextDefaultColor() not to retain the returned color. It returns
+  only a reference to the internal color, which you shouldn't release
+- Added wstrndup()
+- Added WMGetFontName()
+- Added fontpanel callback
+- Added WMSetTableViewHasHorizontalScroller()
+- Fixed bug that could cause SIGSEGV by accessing beyond the end of text in
+  a WINGs textfield widget.
+- Fixed small memory leak in the font panel code.
+- Fixed call to qsort in WMSortArray.
+- Fixed a memleak in the file panel.
+- Double/triple-click selection in text widgets
+  (Vitaly Ovtchinnikov <ov@rbcmail.ru>)
+- Fixed bug in tableview (clicked row callback got incorrect row)
+  (Carlos Torres <vlaadbrain@operamail.com>)
+- Fixed bug in resizing a scrollview
+- Fixed bug with wrong text wrapping (Alexey Voinov <voins@voins.program.ru>)
+- Added wmkrect()
+- Added xdnd v3 support (Sylvain Reynal <sreynal@nerim.net>)
+- Fixed and enhanced text wrapping.
+
+
+Changes since wmaker 0.80.0:
+............................
+
+- fixed a bug in wfindfile() (rewrote wfindfile() with better logic).
+- separated the font caches for normal fonts and fontsets in WINGs (they can
+  have the same names and collide in the cache giving unwanted results)
+- fixed labels not to display '\n' as a character if multiple '\n' are passed
+  but just skip to the next line.
+- better warning when importing non-digit characters in PropList Data.
+- rewrote WMBox to use a WMArray for subviews. with this change fixed a bug
+  about arranging subviews after removing one and a memleak occuring in the
+  same case.
+- Fixed WMGetViewScreenPosition() to consider the window decorations.
+- Added ability to enable/disable individual WMTableViewItems.
+- Fixed textfields regarding interpretation of special keys with modifiers.
+- Fixed some functions that accept a boolean flag as a paramater, to set only
+  1 or 0 for the flag value, not the flag passed by the user.
+- Added 2 functions to retrieve the default system fonts:
+  WMDefaultSystemFont(WMScreen *scr) and WMDefaultBoldSystemFont(WMScreen *scr)
+- Added WMSetButtonImageDimsWhenDisabled() and WMGetButtonEnabled()
+- Cleaned-up the header files of functions/vars declared but not implemented
+- Added WMGetTextFieldDelegate()
+
+
+Changes since wmaker 0.70.0:
+............................
+
+- added an internal strcasecmp() (only on systems where is not present)
+- removed some redundant includes of ../src/config.h when wconfig.h is
+  included too
+- removed a wsyserror() message when reading a property list from file
+  (the programmer should decide if to give that message or just ignore).
+- added a 'Bool recursive' flag to WMMergePLDictionaries()
+- added WMSubtractPLDictionaries()
+
+
+Changes since wmaker 0.65.0:
+............................
+
+- fixed problem with WINGs based apps exiting with a "X_RotateProperties"
+  related error when text was selected in a textfiled.
+- moved wstrdup(), wstrconcat() and wstrappend() from memory.c to string.c
+- added property list handling code making libPropList unnecessary and
+  obsolete. Backward compatibility is provided through the
+  WINGs/proplist-compat.h header file which has #defines from old libPropList
+  function names to new function names with minimal changes. Read this
+  header file and the NEWS file for more details about this subject.
+- Renamed WMGetUDAllKeys() to WMGetUDKeys()
+
+
+Changes since wmaker 0.64.0:
+............................
+
+- made programmatic scroller changes send notifications
+- replaced WMSetBoxExpandsToParent with WMSetViewExpands...
+- added WMGetLabelFont()
+- added WMAddPersistentTimerHandler()
+- Moved all internal handlers (timer, idle and input) to handlers.c
+- simplified wevent.c and wutil.c.
+- fixed handling of input with poll (was broken)
+- fixed mem leak that occured when input handling was done with poll
+- simpler and more straightforward event handling for timer, idle, input
+  and X events (also fixed some problems the old handling logic had)
+- moved timer, idle and input handler definitions and prototypes from
+  WINGs.h to WUtil.h because they're not GUI related.
+- better and more robust handling of events (timer, idle, input, X) in
+  WMMaskEvent(). Also fixed a bug where input and timer events were not
+  treated for undefined periods of time under some circumstances.
+- fixed secure textfields not to allow text selection, to avoid compromising
+  sensitive information by pasting it to a terminal.
+- replaced wmkrange(), wmkpoint() and wmksize() functions with macros.
+- added WMRemoveFromArrayMatching(array, match, cdata), which will remove the
+  first element in the array that is matched by match(item, cdata)==True.
+- added WMArrayFirst(), WMArrayLast(), WMArrayNext() and WMArrayPrevious()
+  functions and also WM_ITERATE_ARRAY() and WM_ETARETI_ARRAY() macros, to make
+  interfaces to WMBag and WMArray similar and to make life a little simpler
+  when iterating through all elements of an array.
+- replaced bags with arrays wherever appropriate. This will improve
+  performance a bit.
+- replaced some recursive code with iterative code in selection.c
+- added WMCreateBlendedPixmapFromRImage()
+- small API change:
+  1. Renamed WMSetApplicationIconImage(), WMGetApplicationIconImage() and
+     WMSetWindowMiniwindowImage() to respectively WMSetApplicationIconPixmap(),
+     WMGetApplicationIconPixmap() and WMSetWindowMiniwindowPixmap()
+     They operate on a WMPixmap which is practically an X Pixmap with no alpha
+     channel information and the new name is more suggestive and also leaves
+     room for the new functions added for operating on images with alpha info.
+  2. Added WMSetApplicationIconImage() and WMGetApplicationIconImage() which
+     operate on an RImage and store alpha information too.
+  3. Added WMCreateApplicationIconBlendedPixmap() which will take the image
+     set by WMSetApplicationIconImage() and will combine it with a color.
+     If color is NULL it will blend using the default panel color (#aeaaae)
+  All these changes will allow WINGs to handle images with alpha blending
+  correctly in panels and wherever else needed. More about in NEWS.
+- updated panels to use the newly available RImages if present and fallback
+  to old WMPixmaps if not, to properly show alpha blended images.
+- replaced some still left malloc's with wmalloc's.
+- fixed a bug in WMReparentWidget()
+- added WMReparentWidget() to WINGs.h
+- fixed a bug that made the scroller knob jump backwards when dragged (this
+  bug had no relation with the behavior that #define STRICT_NEXT_BEHAVIOUR
+  attempts to accomplish).
+- fixed scrolling direction with mouse wheel for horizontal scroller.
+
+
+changes since wmaker 0.63.1:
+............................
+- added WMRunModalLoop() and WMBreakModalLoop()
+- added WMSetBoxExpandsToParent()
+- added WMRemoveBoxSubview()
+- moved WINGs headers in a WINGs subdirectory when installed.
+  use #include <WINGs/header_file_name> in your application from now on.
+  Also updated get-{wings|wutil}-flags.
+- Fixed a mem leak in WMList.
+- Fixed a bug that caused sigsegv for a WMList with more than 32767 items.
+- Added an example of how to create a server type program with WMConnection.
+- added WMOpenScreen()
+
+
+changes since wmaker 0.62.1:
+............................
+- added WRuler widget
+- added WText widget (rtf multiline text widget)
+	Nwanua Elumeze <nwanua@colorado.edu>
+- added a new AUTO option for the UseMultiByte option
+- added WMRaiseWidget()/WMLowerWidget()
+- added missing EscapeTextMovement to textfield delegate/notification
+- added WMGetLabelText()
+- added WMReparentWidget()
+- added WMCreateTabViewItem()
+- added W_CreateUnmanagedTopView()
+- added wtokenjoin(), wtokensplit(), wtokenfree(), wtrimspace()
+- added WMWidgetIsMapped()
+- added WMSetApplicationIconWindow()
+- restructured the directory tree. Added Documentation, Examples and Tests
+  subdirectories
+- removed WMArrayBag and reorganized WMTreeBag to be WMBag.
+- added WMArray class.
+- added WMSetWindowUserPosition()
+- added WMGetListSelectedItems()
+- added WMSetListAllowMultipleSelection(), WMListAllowsMultipleSelection().
+- added WMSetListAllowEmptySelection(), WMListAllowsEmptySelection().
+- WMListSelectionDidChangeNotification passes NULL as the notification
+  client data (previously passed the selected item row).
+- added WMUnselectListItem(), WMSelectAllListItems(), WMUnselectAllListItems()
+- better behavior of wheel mices in WMList. Simple mouse wheel events
+  will scroll by 1/3 of the WMList height. Using Shift as a modifier will
+  scroll line by line, while using Control as a modifier will scroll page
+  by page.
+- better behavior of WMScroller regarding mouse wheel events. 'Shift' modifier
+  will scroll line by line, while 'Control' modifier will scroll page by page.
+- fixed some buffer overflow allowing bugs.
+- added WSDecrementWheel and WSIncrementWheel for handling mouse wheel in
+  scrollers and scrolled widgets. This should be treated like the WSxxxPage
+  counterparts, except it should scroll by page_size/3 instead of one full page
+- added WMSetBrowserAllowMultipleSelection(), WMSetBrowserAllowEmptySelection()
+  WMBrowserAllowsMultipleSelection() and WMBrowserAllowsEmptySelection()
+- WMBrowser now allows multiple selections.
+- Added WMGetBrowserPaths() to retrieve the paths for browsers that allow
+  multiple selections.
+- WMDestroyWidget() now calls WMUnmapWidget() first
+- added WMScrollerDidScrollNotification to scroller
+- added WMGetScrollViewVisibleRect()
+- fixed a mem leak in the browser code.
+- renamed wstrappend() to wstrconcat(). wstrconcat(str1, str2) concatenates
+  str1 with str2 and returns that in a newly malloc'ed string.
+  Be sure to rename wstrappend with wstrconcat in your code too, else
+  hazardous things can happen!
+- implemented a new wstrappend() function. wstrappend(dst, src) will append
+  src to dst modifing dst and returning a pointer to it. No new string is
+  generated, except if dst is NULL, in which case its the same as calling
+  wstrdup(src).
+  dst can ONLY be NULL or a dynamically allocated string (obtained from a
+  call to malloc, realloc, wmalloc, wrealloc, ...). dst CANNOT be a static
+  or a constant string!
+- added wmessage() for printing a variable formatted string to stderr, with
+  the program name prepended to it. Similar to wwarning(), except that it
+  doesn't add "warning:" in the output message.
+- added WMBox widget
+- added WMAddTabViewItemWithView()
+- added W_SetViewCursor()
+- made Extra widgets library
+- added table widget in Extras library
+- added WMGetConnectionUnsentData() (WMGetConnectionQueuedData() too as an
+  alias).
+- added WMSetConnectionCloseOnExec() to specify if the socket associated
+  with a connection survives an exec* call or not. When a new connection is
+  created using the WMCreate... or WMAcceptConnection() calls, it has the
+  close on exec flag set automatically to 'True' by the library. Unless
+  you want to let the socket of some connection to survive across an exec*
+  call, you need not to call this function.
+- removed all the wsyserror() and wwarning() calls from host.c and
+  connection.c and replaced where appropriate with assertions. If a function
+  returns some invalid result, you can still get the system error message if
+  you need, by calling wsyserrorwithcode() and passing WCErrorCode, if
+  WCErrorCode > 0. If WCErrorCode==0, that is not a system error, and
+  wsyserrorwithcode() should not be called in this case.
+- added WMNextHashEnumeratorKey() to retrieve all keys in some hash enumerator
+  one by one.
+- fixed a bug with mouse wheels scrolling in scrollers even with the widget
+  fully visible.
+- Fixed a memory leak (the destroy function for a view was never called and
+  as a result the shaded windows didn't go away when closed. The non-shaded
+  windows were unmapped on close but not destroyed either so they only
+  apparently went away, but continued to use memory).
+- Fixed a bug in the hashtable code which free'd the whole item instead of
+  just the item key in WMResetHashTable() (possible source of SIGSEGVs)
+
+
+changes since wmaker 0.62.0:
+............................
+- added WMSetWidgetDefaultFont(), WMSetWidgetDefaultBoldFont()
+
+
+
+changes since wmaker 0.62.0:
+............................
+- added WM{S,G}etDataFormat()
+- added drag and drop
+- changed selection code
+- added clientdata to WMFindInBag
+- removed SetWindowInitialSize()
+- added SetWindowAspectRatio()
+- added initial timeout when establishing a connection.
+- added WMSetConnectionDefaultTimeout() and WMSetConnectionOpenTimeout();
+- added WMGetConnectionTimeoutState()
+
+changes since wmaker 0.61.1:
+............................
+
+- WARNING: semantic of bags has changed!
+	An index assigned to an item will always keep that index unless
+	you insert an item before it.
+
+	For example:
+		bag = WMCreateBag();
+		WMSetInBag(bag, 10, "bla");
+	That code will put "bla" in index 10, instead of 0, as it used to be.
+- fixed WMInsertInBag(). It ignored index, and always put the new item at end.
+- added WMSaveUserDefaults().
+- rewrote WMPopUpButton to use WMMenuItem
+- added WMGetPopUpButtonMenuItem(WMPopUpButton *bPtr, int index)
+- WMSortListItemsWithComparer(WMList *lPtr, (int)(f)(const void*, const void*))
+- WMSortBrowserColumnWithComparer()
+- fixed bug with sorting list items.
+- fixed bug in handling keyboard input associated with selection and
+  notification sending.
+- filepanel puts dirs on top of list (Wolff <wolff@cybercable.fr>)
+- added WMReplaceInBag (Wolff <wolff@cybercable.fr>)
+- added vertical views and multiple views in WMSplitView (Wolff <wolff@cybercable.fr>)
+- changed values of parameter values of WMSplitViewConstrainProc()
+- configurable default fontsize patch (Igor P. Roboul <igor@mordor.myip.org>)
+- fixed a bug that crashed the programm when a popup button was scrolled.
+- fixed a bug that caused incorrect drawing position of the popup indicator.
+- fixed a bug that prevented selecting no item (-1) in a popup button.
+- an assertion will be raised if the program tries to select a popup button
+  item that is beyond the total number of items present in the popup button.
+- changed names of functions for SplitView to be consistent. Some contained
+  SubView while other Subview. Now all have Subview.
+- fixed a bug in how input events were posted. Establishing 2 or more input
+  handlers for the same file descriptor, handling different (read/write/except)
+  events, caused wrong handlers to be called.
+- Reimplemented the input and idle handlers with WMBag to avoid a functional
+  problem with them: inability to remove handlers next to the called one, from
+  the called handler itself. Trying to do this with the old version caused the
+  program to crash.
+- changed wrealloc behaviour to be like this: new = wrealloc(old, new_size);
+    1. if old is NULL, return wmalloc(new_size).
+    2. if new_size is 0, call wfree(old), and return NULL.
+    3. if both old is a valid pointer and new_size>0, call realloc.
+- added wstrerror(int errnum) to return the string associated with errnum.
+- new wsyserrorwithcode(int error, const char* fmt, ...), similar to
+  wsyserror(), but printing the message for the specified error code.
+- added 3 new classes: WMData, WMHost and WMConnection
+- fixed a big memory leak in the color panel code (from Pascal Hofstee).
+- added scrolling to tabview
+
+changes since wmaker 0.61.0:
+............................
+
+- added WMGetTextFieldFont()
+- escape key in panels (craig nellist <crn@ozemail.com.au>)
+- applied patch with fixes and enhancements to textfield
+	(Franck Wolff <wolff@cybercable.fr>)
+- changed WMList to use WMBag internally, instead of a linked list
+- replaced WMAddSortedListItem() with WMSortListItems()
+- replaced WMAddSortedBrowserItem() with WMSortBrowserColumn()
+
+changes since wmaker 0.60.0:
+............................
+
+- added WMScreenWidth() and WMScreenHeight() functions.
+- fixed some problems when compiling with non gcc compilers.
+- added WMSetTextFieldFont()
+- added WMSetButtonImageDefault() (craig nellist <crn@ozemail.com.au>)
+- added WMBag (array/list)
+- added libWUtil, a library that is a subset of libWINGs. It contains utils
+  that can be used in writing non-GUI programs. They include: hashes,
+  notifications, input/idle/timer handlers, user defaults database handling,
+  memory handling, application resource handling, etc.
+  All the non-GUI stuff from libWINGs is present.
+  Still linWINGs contain all this stuff so if you use libWINGs, you don't
+  need to link against libWUtil too.
+  One notable aspect of libWUtil is that it has a modified version of the
+  event handling function. It is named WHandleEvents() and will handle all
+  input/idle/timer events the app has.
+  If your app has a permanent input handler (as for example a socket a server
+  is listening on), then the main loop of the app can be:
+  	while(1) {
+    	    WHandleEvents();
+  	}
+  but if there is no permanent input handler, you need to add some delay to
+  avoid a too high cpu load by your program:
+  	while(1) {
+            WHandleEvents();
+            wusleep(5000);
+        }
+  A permanent input handler is one that is established when the program starts
+  and is present until the program exits.
+  One that is deleted and later reinstalled, is not considered permanent.
+  This difference is because if there is some input handler, the function will
+  block until some event appears, while if there is no input handler the
+  function will return almost immediately (after handling the timer/idle
+  stuff).
+
+  Except the stuff declared in WUtil.h, the following functions declared in
+  WINGs.h are also present in libWUtil (you will need to #include <WINGs.h>
+  if you use one of these):
+	WMInitializeApplication(char *applicationName, int *argc, char **argv);
+	WMSetResourcePath(char *path);
+	WMGetApplicationName();
+	WMPathForResourceOfType(char *resource, char *ext);
+	WMAddTimerHandler(int milliseconds, WMCallback *callback, void *cdata);
+	WMDeleteTimerWithClientData(void *cdata);
+	WMDeleteTimerHandler(WMHandlerID handlerID);
+	WMAddIdleHandler(WMCallback *callback, void *cdata);
+	WMDeleteIdleHandler(WMHandlerID handlerID);
+	WMAddInputHandler(int fd, int condition, WMInputProc *proc,
+        		  void *clientData);
+	WMDeleteInputHandler(WMHandlerID handlerID);
+- added progress indicator widget
+- Changed WMSetWindowUPosition() and WMSetWindowUSize() to
+  WMSetWindowInitialPosition() and WMSetWindowInitialSize() respectively,
+  for better naming conventions.
+
+
+changes since wmaker 0.53.0:
+............................
+
+- added balloon help
+- fixed a bug with setting initial path in browsers.
+- added WMSetButtonImageDimsWhenDisabled()
+- changed simple callback/notifications to delegate-like stuff. Affected
+  widgets are:
+  	WMBrowser
+	- WMSetBrowserFillProc() was replaced with WMSetBrowserDelegate
+	- WMBrowserDidScrollNotification was replaced with a delegate callback
+
+	WMTextField (not completed yet)
+	The notifications will still work, but using the delegate is preferable
+
+  How to convert old code to delegate callbacks:
+  	1 - create a variable (static or dynamic) of the type of the
+	    delegate for the widget type.
+	2 - Replace the notification observers with the equivalent
+	    delegate callbacks.
+	3 - Put pointers to the callbacks in the delegate variable.
+
+	Take a look in wfilepanel.c to see how it is used there.
+
+- changed W_ViewProcedureTable to delegates
+	This will only affect user created widgets. If you have a custom
+	widget, you will need to update the callbacks and the declaration
+	of the W_ViewProcedureTable variable to be a W_ViewDelegate,
+	which is declared in WINGsP.h  To setup the delegate, assign
+	the delegate variable to view->delegate.
+
+- WMTextField
+	Removed all the didChange notifications that were sent when the text
+	was changed programmatically. Only changes made by user interaction
+	will be notified now. If you need the old behaviour, send notifications
+	manually when you change the text.
+
+- added WMTabView
+- added WMGetColorPanelColor(WMColorPanel *panel)
+- made WMGetUDStringForKey() to only return a reference to the string, not a
+  wstrdup()'ed copy. DO NOT FREE IT ANYMORE!
+- added MultiByteText option to userdefaults file to control use of multibyte
+  string drawing functions
+- renamed WMCreateFont() to WMCreateFontSet()
+- renamed WMCreateFontInDefaultEncoding() to WMCreateNormalFont()
+- added WMCreateFont() with different semantics
+
+
+changes since wmaker 0.52.0:
+............................
+
+- added int WMGetBrowserMaxVisibleColumns(WMBrowser *bPtr);
+
+
+changes since wmaker 0.51.2:
+............................
+
+- added WMColorWellDidChangeNotification
+- added wfindfileinarray()
+- fixed bug in window title setting
+	(MANOME Tomonori <manome@itlb.te.noda.sut.ac.jp>)
+
+changes since wmaker 0.51.1:
+............................
+
+- wusergnusteppath() will return a statically allocated string now.
+ DO NOT FREE IT ANYMORE!!
+
+
+
+changes since wmaker 0.51.0:
+............................
+
+- applied c++ compat header patch from Martynas Kunigelis <mkunigelis@alna.lt>
+- added WMSetTextFieldBeveled()
+- removed W_GC() : use WMColorGC() instead
+- added WMCreatePixmap()
+- changed WMSetTextFieldEnabled() to WMSetTextFieldEditable()
+
+changes since wmaker 0.50.1:
+............................
+
+- fixed various bugs
+- added patch from Franck Wolff <frawolff@club-internet.fr>, with
+  many fixes and enhancements
+- added notification queues, asynchronous notifications etc.
+- added WMSetBrowserDoubleAction()
+- fixed list double click action
+
+changes since wmaker 0.50.2:
+............................
+
+- added wsetabort() - look WUtil.h
+- fixed bug in WMList resize
+- added notification sending when changing textfield programatically
+- removed WMHideWindow()
+- fixed bug in WMCloseWindow()
+- added textfield selection patch
+- added color panel code
+- added auto name completion for the file panel
+- added function to select text range, and to set cursor position in text
+  fields programatically
+
+changes since wmaker 0.20.3:
+............................
+
+- added WMSetSliderImage(), WMSetSliderKnobThickness()
+- added WMGetListItemHeight()
+- added WMListDidScrollNotification
+- added WSetColorWellBordered()
+- added hacky color dragging in colorwell
+- added poll() support in WMNextEvent. WARNING: the stuff needed for
+  WMAddInputHandler() is not yet implemented for the poll stuff
+- added WMSetFilePanelAccessoryView(), WMGetFilePanelAccessoryView()
+- added WMSetPopUpButtonEnabled()
+- added WMGetLabelImage()
+- autoscroll for popup button menus
+- added WMDrawPixmap()
+- WARNING: changed parameter list for WMListDrawProc
+
+changes since wmaker 0.20.2:
+............................
+
+- WMSetBrowserMaxVisibleColumns() - untested
+
+
+
+changes since wmaker 0.20.0:
+............................
+
+- added generic object field for WMListItem. This is for hanging generic
+  clientdata
+
+
+changes since wmaker 0.20.0:
+............................
+
+- changed WMGetFilePanelFile() with WMGetFilePanelFileName()
+- made SavePanel
+
+changes since wmaker 0.19.3:
+............................
+
+- added WMCreatePanelForWindow()
+- added extra parent parameter for filepanel, alertpanel and inputpanel
+- WMCloseWindow()
+- WMChangePanelOwner()
+- added WMAddInputHandler()
+- change range related function arguments (WMTextField) to use WMRange
+
+changes since wmaker 0.19.1:
+............................
+
+- added wstrappend()
+- fixed bug when changing selected radio button by hand
+
+changes since wmaker 0.18.1:
+............................
+
+- removed textHeight arg from W_PaintImageAndText
+- added WMCreateWindowWithStyle()
+- added WMSetWindowBaseSize() and ResizeIncrements()
+- added WMSetWindowLeve()
+- added WMSetWindowDocumentEdited()
+- added WMSetScrollViewLineScroll(), WMSetScrollViewPageScroll()
+- added WMSetWindowMiniwindowTitle()
+- added WMSetWindowMiniwindowImage()
+
+changes since wmaker 0.18.0:
+............................
+
+- added functions to get RGB components and "#rrggbb" string from WMColor.
+- added function to create color from a name
+- fixed bug that caused blocking until some new event arrives, even
+  when there already were events in the queue
+  (like having to move the pointer over window to force the window to be
+  painted)
+
+changes since wmaker 0.17.5:
+............................
+
+I don't remember everything, but here it goes:
+
+- fixed some bugs in text field
+- added a incomplete implementation of split view (not yet usable)
+- added a slider
+- changed the filepanel stuff. Each application can have only 1 file panel.
+The same panel will be reused every time you call for it, unless you free it.
+- changed semantics of WMCreateFont() so that it returns NULL if the requested
+  font can't be loaded
+- removed WMAddDestroyCallback()
+- fixed bug in WMRemovePopUpButtonItem()
+- added function for user specified item height in WMList
+- added WMSetPopUpButtonText(). It will set the default text in the button
+  when no options are selected
+- fixed bug in remove/add item in already mapped popupbuttons. Note: it is
+  not good practice to change the contents of a popup button when it's
+  already visible and the user has probably interacted with it.
+- fixed behaviour of "radio buttons"
+- WMInitializeApplication() must be the first function to be called in the
+  program
+- removed applicationName, argc and argv arguments from the WMCreateScree...
+  functions
+- WMReleaseColor(scr,color) changed to WMReleaseColor(color)
+- WMPaintColorRectangle() changed to WMPaintColorSwatch()
+- added various functions in font and color handling
+- added WMSetButtonFont()
+- changed WMCreateCommandButton() so that the buttons it creates will change
+	their label when pushed
+- added WMGetSystemPixmap(WMScreen *scr, int image)
+- added partial I18N support
+- added libPropList requirement and some related utility functions
+- added a interface to prooplist, so that it works as a user defaults db
+- added WMWidthOfString() (removed WMFontWidthOfString())
+- added WMDrawString()
+- added WMSetTextFieldSecure(WMTextField *tPtr, Bool flag)
+- WMGetListItem() will dup the returned string
+- removed need for ProgName being defined
+- rewrote hashtable stuff and made it available for outside use
+- added notification functions, with view resize notification
+- added WMSetWindowMinSize() and MaxSize()
+- text editing notification
+- added WMSetListPosition() etc.
+- added WMInsertBrowserItem()
+- the above 2 functions return WMListItem*, instead of Bool
+- rewrote browser
+- WMGetListItem() will return WMListItem*
+- removed WMGetListItems() and WMSetListItems()
+- fixed focus stuff for multi-window apps
+- changed all WMList function names that contained index to row

bazel/WINGs/Documentation/Makefile.am

@@ -0,0 +1,6 @@
+## automake input file for WINGs - Documentation
+
+AUTOMAKE_OPTIONS =
+
+EXTRA_DIST =
+

bazel/WINGs/Examples/Makefile.am

@@ -0,0 +1,21 @@
+## automake input file for WINGs - Examples
+
+AUTOMAKE_OPTIONS =
+
+
+noinst_PROGRAMS = fontl puzzle colorpick
+
+
+LDADD= $(top_builddir)/WINGs/libWINGs.la $(top_builddir)/wrlib/libwraster.la \
+	$(top_builddir)/WINGs/libWUtil.la \
+	@XFT_LIBS@ @INTLIBS@ @XLIBS@
+
+colorpick_DEPENDENCIES = $(top_builddir)/WINGs/libWINGs.la
+
+fontl_DEPENDENCIES = $(top_builddir)/WINGs/libWINGs.la
+
+puzzle_DEPENDENCIES = $(top_builddir)/WINGs/libWINGs.la
+
+
+AM_CPPFLAGS = -I$(top_srcdir)/WINGs -I$(top_srcdir)/wrlib -I$(top_srcdir)/src \
+	-DRESOURCE_PATH=\"$(datadir)/WINGs\" @HEADER_SEARCH_PATH@

bazel/WINGs/Examples/README

@@ -0,0 +1,12 @@
+
+
+Files:
+-----
+
+colorpick	- a color picker
+
+puzzle		- a nice zuPzel =)
+
+fontl		- a map of all characters with their corresponding ascii,
+		  hex, decimal and octal representations.
+

bazel/WINGs/Examples/colorpick.c

@@ -0,0 +1,40 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <WINGs/WINGs.h>
+
+void showSelectedColor(void *self, void *cdata)
+{
+	WMColorPanel *panel = (WMColorPanel *) self;
+
+	(void) cdata;
+	printf("Selected Color: %s\n", WMGetColorRGBDescription(WMGetColorPanelColor(panel)));
+}
+
+int main(int argc, char **argv)
+{
+	Display *dpy;
+	WMScreen *scr;
+
+	WMInitializeApplication("wmcolorpick", &argc, argv);
+
+	dpy = XOpenDisplay("");
+	if (!dpy) {
+		printf("could not open display\n");
+		exit(1);
+	}
+
+	scr = WMCreateScreen(dpy, DefaultScreen(dpy));
+
+	{
+		WMColorPanel *panel = WMGetColorPanel(scr);
+
+		WMSetColorPanelAction(panel, showSelectedColor, NULL);
+
+		WMShowColorPanel(panel);
+	}
+
+	WMScreenMainLoop(scr);
+
+	return 0;
+}

bazel/WINGs/Examples/fontl.c

@@ -0,0 +1,100 @@
+/*
+ * WINGs demo: font lister
+ *
+ *  Copyright (c) 1998-2003 Alfredo K. Kojima
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <WINGs/WINGs.h>
+#include <WINGs/WUtil.h>
+#include <inttypes.h>
+
+void wAbort()
+{
+	exit(0);
+}
+
+void show(WMWidget * self, void *data)
+{
+	char buf[60];
+	void *d;
+	WMLabel *l = (WMLabel *) data;
+	d = WMGetHangedData(self);
+	sprintf(buf, "%"PRIiPTR" -  0x%"PRIxPTR" - 0%"PRIoPTR, (intptr_t) d, (intptr_t) d, (intptr_t) d);
+	WMSetLabelText(l, buf);
+}
+
+void quit(WMWidget * self, void *data)
+{
+	(void) self;
+	(void) data;
+	exit(0);
+}
+
+int main(int argc, char **argv)
+{
+	Display *dpy;
+	WMWindow *win;
+	WMScreen *scr;
+	WMButton *lab, *l0 = NULL;
+	WMLabel *pos;
+	int x, y, c;
+	char buf[20];
+
+	WMInitializeApplication("FontView", &argc, argv);
+
+	dpy = XOpenDisplay("");
+	if (!dpy) {
+		wfatal("cant open display");
+		exit(0);
+	}
+
+	scr = WMCreateSimpleApplicationScreen(dpy);
+
+	win = WMCreateWindow(scr, "main");
+	WMResizeWidget(win, 20 * 33, 20 + 20 * 9);
+	WMSetWindowTitle(win, "Font Chars");
+	WMSetWindowCloseAction(win, quit, NULL);
+	pos = WMCreateLabel(win);
+	WMResizeWidget(pos, 20 * 33, 20);
+	WMMoveWidget(pos, 10, 5);
+
+	c = 0;
+	for (y = 0; y < 8; y++) {
+		for (x = 0; x < 32; x++, c++) {
+			lab = WMCreateCustomButton(win, WBBStateLightMask);
+			WMResizeWidget(lab, 20, 20);
+			WMMoveWidget(lab, 10 + x * 20, 30 + y * 20);
+			sprintf(buf, "%c", c);
+			WMSetButtonText(lab, buf);
+			WMSetButtonAction(lab, show, pos);
+			WMHangData(lab, (void *)(uintptr_t) c);
+			if (c > 0) {
+				WMGroupButtons(l0, lab);
+			} else {
+				l0 = lab;
+			}
+		}
+	}
+	WMRealizeWidget(win);
+	WMMapSubwidgets(win);
+	WMMapWidget(win);
+	WMScreenMainLoop(scr);
+	return 0;
+}

bazel/WINGs/Examples/puzzle.c

@@ -0,0 +1,236 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <WINGs/WINGs.h>
+#include <stdint.h>
+
+#define MAX_SIZE 	10*10
+
+WMWindow *win;
+WMButton *Button[MAX_SIZE];
+signed char Map[MAX_SIZE];
+int Size = 4;
+int MoveCount;
+
+#define MAP(x,y)  Map[(x)+(y)*Size]
+
+int WinSize = 120;
+
+Bool CheckWin(void)
+{
+	int i;
+
+	for (i = 0; i < Size * Size - 1; i++) {
+		if (Map[i] != i)
+			return False;
+	}
+
+	return True;
+}
+
+void MoveButton(int button, int x, int y)
+{
+	WMMoveWidget(Button[button], x * (WinSize / Size), y * (WinSize / Size));
+}
+
+Bool SlideButton(int button)
+{
+	int x = 0, y = 0, done = 0;
+
+	/* locate the button */
+	for (y = 0; y < Size; y++) {
+		for (x = 0; x < Size; x++) {
+			if (MAP(x, y) == button) {
+				done = 1;
+				break;
+			}
+		}
+		if (done)
+			break;
+	}
+
+	if (x > 0 && MAP(x - 1, y) < 0) {
+		MAP(x, y) = -1;
+		MoveButton(button, x - 1, y);
+		MAP(x - 1, y) = button;
+	} else if (x < Size - 1 && MAP(x + 1, y) < 0) {
+		MAP(x, y) = -1;
+		MoveButton(button, x + 1, y);
+		MAP(x + 1, y) = button;
+	} else if (y > 0 && MAP(x, y - 1) < 0) {
+		MAP(x, y) = -1;
+		MoveButton(button, x, y - 1);
+		MAP(x, y - 1) = button;
+	} else if (y < Size - 1 && MAP(x, y + 1) < 0) {
+		MAP(x, y) = -1;
+		MoveButton(button, x, y + 1);
+		MAP(x, y + 1) = button;
+	} else {
+		return False;
+	}
+	return True;
+}
+
+#define SWAP(a,b) {int tmp; tmp=a; a=b; b=tmp;}
+
+void ResetGame(void)
+{
+	int i, x, y, ox, oy;
+
+	MoveCount = 0;
+
+	for (i = 0; i < Size * Size - 1; i++) {
+		Map[i] = i;
+	}
+	Map[i] = -1;
+	ox = x = Size - 1;
+	oy = y = Size - 1;
+	for (i = 0; i < 1000; i++) {
+		int ok;
+		ok = 1;
+		switch (rand() % 4) {
+		case 0:
+			if (x > 0)
+				x--;
+			else
+				ok = 0;
+			break;
+		case 2:
+			if (x < Size - 1)
+				x++;
+			else
+				ok = 0;
+			break;
+		case 1:
+			if (y > 0)
+				y--;
+			else
+				ok = 0;
+			break;
+		case 3:
+			if (y < Size - 1)
+				y++;
+			else
+				ok = 0;
+			break;
+		}
+		if (ok) {
+			MoveButton(MAP(x, y), ox, oy);
+
+			SWAP(MAP(ox, oy), MAP(x, y));
+
+			while (XPending(WMScreenDisplay(WMWidgetScreen(win)))) {
+				XEvent ev;
+				WMNextEvent(WMScreenDisplay(WMWidgetScreen(win)), &ev);
+				WMHandleEvent(&ev);
+			}
+			ox = x;
+			oy = y;
+		}
+	}
+}
+
+void buttonClick(WMWidget * w, void *ptr)
+{
+	char buffer[300];
+
+	if (SlideButton((uintptr_t)ptr)) {
+		MoveCount++;
+
+		if (CheckWin()) {
+			sprintf(buffer, "You finished the game in %i moves.", MoveCount);
+
+			if (WMRunAlertPanel(WMWidgetScreen(w), win, "You Won!", buffer,
+					    "Wee!", "Gah! Lemme retry!", NULL) == WAPRDefault) {
+				exit(0);
+			}
+
+			ResetGame();
+		}
+	}
+}
+
+static void resizeObserver(void *self, WMNotification * notif)
+{
+	WMSize size = WMGetViewSize(WMWidgetView(win));
+	int x, y;
+
+	(void) self;
+	(void) notif;
+
+	WinSize = size.width;
+	for (y = 0; y < Size; y++) {
+		for (x = 0; x < Size; x++) {
+			if (MAP(x, y) >= 0) {
+				WMResizeWidget(Button[(int)MAP(x, y)], WinSize / Size, WinSize / Size);
+				WMMoveWidget(Button[(int)MAP(x, y)], x * (WinSize / Size), y * (WinSize / Size));
+			}
+		}
+	}
+
+}
+
+int main(int argc, char **argv)
+{
+	Display *dpy;
+	WMScreen *scr;
+	int x, y, i;
+
+	WMInitializeApplication("Puzzle", &argc, argv);
+
+	dpy = XOpenDisplay("");
+	if (!dpy) {
+		printf("could not open display\n");
+		exit(1);
+	}
+
+	scr = WMCreateScreen(dpy, DefaultScreen(dpy));
+
+	win = WMCreateWindow(scr, "puzzle");
+	WMResizeWidget(win, WinSize, WinSize);
+	WMSetWindowTitle(win, "zuPzel");
+	WMSetWindowMinSize(win, 80, 80);
+	WMSetWindowAspectRatio(win, 2, 2, 2, 2);
+	WMSetWindowResizeIncrements(win, Size, Size);
+	WMSetViewNotifySizeChanges(WMWidgetView(win), True);
+	WMAddNotificationObserver(resizeObserver, NULL, WMViewSizeDidChangeNotification, WMWidgetView(win));
+
+	for (i = y = 0; y < Size && i < Size * Size - 1; y++) {
+		for (x = 0; x < Size && i < Size * Size - 1; x++) {
+			char buf[32];
+			WMColor *color;
+			RColor col;
+			RHSVColor hsv;
+
+			hsv.hue = i * 360 / (Size * Size - 1);
+			hsv.saturation = 120;
+			hsv.value = 200;
+
+			RHSVtoRGB(&hsv, &col);
+
+			color = WMCreateRGBColor(scr, col.red << 8, col.green << 8, col.blue << 8, False);
+
+			MAP(x, y) = i;
+			Button[i] = WMCreateButton(win, WBTMomentaryLight);
+			WMSetWidgetBackgroundColor(Button[i], color);
+			WMReleaseColor(color);
+			WMSetButtonAction(Button[i], buttonClick, (void *)(uintptr_t) i);
+			WMResizeWidget(Button[i], WinSize / Size, WinSize / Size);
+			WMMoveWidget(Button[i], x * (WinSize / Size), y * (WinSize / Size));
+			sprintf(buf, "%i", i + 1);
+			WMSetButtonText(Button[i], buf);
+			WMSetButtonTextAlignment(Button[i], WACenter);
+			i++;
+		}
+	}
+
+	WMMapSubwidgets(win);
+	WMMapWidget(win);
+	WMRealizeWidget(win);
+
+	ResetGame();
+
+	WMScreenMainLoop(scr);
+
+	return 0;
+}

bazel/WINGs/Extras/Makefile.am

@@ -0,0 +1,30 @@
+## automake input file for WINGs
+
+AUTOMAKE_OPTIONS =
+
+# is this a kluge? if so, how should i do it?
+includedir = @includedir@/WINGs
+
+include_HEADERS = wtableview.h wtabledelegates.h
+
+
+lib_LTLIBRARIES = libExtraWINGs.la
+
+noinst_PROGRAMS = tableview
+
+EXTRA_DIST =
+
+libExtraWINGs_la_SOURCES = 	\
+	wtableview.c \
+	wtabledelegates.c \
+	wtableview.h \
+	wtabledelegates.h
+
+AM_CPPFLAGS = -I$(top_srcdir)/wrlib -I$(top_srcdir)/WINGs \
+	-DRESOURCE_PATH=\"$(datadir)/WINGs\" @HEADER_SEARCH_PATH@
+
+LDADD= $(top_builddir)/WINGs/libWINGs.la $(top_builddir)/wrlib/libwraster.la \
+	$(top_builddir)/WINGs/libWUtil.la \
+	@XFT_LIBS@ @INTLIBS@ @XLIBS@
+
+tableview_LDADD = wtableview.o wtabledelegates.o $(LDADD)

bazel/WINGs/Extras/tableview.c

@@ -0,0 +1,132 @@
+
+#include <WINGs/WINGs.h>
+#include <stdio.h>
+#include <stdint.h>
+#include "wtableview.h"
+#include "wtabledelegates.h"
+
+static char *col1[20] = { 0 };
+
+static int col2[20];
+
+static char *options[] = {
+	"Option1",
+	"Option2",
+	"Option3",
+	"Option4",
+	"Option5"
+};
+
+int numberOfRows(WMTableViewDelegate * self, WMTableView * table)
+{
+	(void) self;
+	(void) table;
+
+	return 20;
+}
+
+void *valueForCell(WMTableViewDelegate * self, WMTableColumn * column, int row)
+{
+	(void) self;
+	/*WMTableView *table = (WMTableView*)WMGetTableColumnTableView(column); */
+	int i;
+
+	if (col1[0] == 0) {
+		for (i = 0; i < 20; i++) {
+			char buf[128];
+
+			sprintf(buf, "Test row %i", i);
+
+			col1[i] = wstrdup(buf);
+			col2[i] = 0;
+		}
+	}
+	if ((uintptr_t)WMGetTableColumnId(column) == 1)
+		return col1[row];
+	else
+		return (void *)(uintptr_t) col2[row];
+}
+
+void setValueForCell(WMTableViewDelegate * self, WMTableColumn * column, int row, void *data)
+{
+	(void) self;
+
+	if ((uintptr_t)WMGetTableColumnId(column) == 1)
+		col1[row] = data;
+	else
+		col2[row] = (uintptr_t) data;
+}
+
+static WMTableViewDelegate delegate = {
+	NULL,
+	numberOfRows,
+	valueForCell,
+	setValueForCell
+};
+
+void clickedTable(WMWidget * w, void *self)
+{
+	(void) w;
+	int row = WMGetTableViewClickedRow((WMTableView *) self);
+
+	WMEditTableViewRow(self, row);
+}
+
+int main(int argc, char **argv)
+{
+	WMScreen *scr;
+	WMWindow *win;
+	WMTableView *table;
+	WMTableColumn *col;
+	WMTableColumnDelegate *colDeleg;
+
+	WMInitializeApplication("test", &argc, argv);
+
+	scr = WMOpenScreen(NULL);
+
+	XSynchronize(WMScreenDisplay(scr), 1);
+
+	win = WMCreateWindow(scr, "eweq");
+	WMResizeWidget(win, 400, 200);
+	WMMapWidget(win);
+
+	table = WMCreateTableView(win);
+	WMSetTableViewHasHorizontalScroller(table, 0);
+	WMSetViewExpandsToParent(WMWidgetView(table), 10, 10, 10, 10);
+	WMSetTableViewBackgroundColor(table, WMWhiteColor(scr));
+	/*WMSetTableViewGridColor(table, WMGrayColor(scr)); */
+	WMSetTableViewHeaderHeight(table, 20);
+	WMSetTableViewDelegate(table, &delegate);
+	WMSetTableViewAction(table, clickedTable, table);
+
+	colDeleg = WTCreateStringEditorDelegate(table);
+
+	col = WMCreateTableColumn("Group");
+	WMSetTableColumnWidth(col, 180);
+	WMAddTableViewColumn(table, col);
+	WMSetTableColumnDelegate(col, colDeleg);
+	WMSetTableColumnId(col, (void *)1);
+
+	colDeleg = WTCreateEnumSelectorDelegate(table);
+	WTSetEnumSelectorOptions(colDeleg, options, 5);
+
+	col = WMCreateTableColumn("Package");
+	WMSetTableColumnWidth(col, 140);
+	WMAddTableViewColumn(table, col);
+	WMSetTableColumnDelegate(col, colDeleg);
+	WMSetTableColumnId(col, (void *)2);
+
+	colDeleg = WTCreateBooleanSwitchDelegate(table);
+
+	col = WMCreateTableColumn("Bool");
+	WMSetTableColumnWidth(col, 50);
+	WMAddTableViewColumn(table, col);
+	WMSetTableColumnDelegate(col, colDeleg);
+	WMSetTableColumnId(col, (void *)2);
+
+	WMMapWidget(table);
+	WMRealizeWidget(win);
+	WMScreenMainLoop(scr);
+
+	return 0;
+}

bazel/WINGs/Extras/wtabledelegates.c

@@ -0,0 +1,522 @@
+
+#include <stdint.h>
+#include <WINGs/WINGsP.h>
+
+#include "wtableview.h"
+
+#include "wtabledelegates.h"
+
+typedef struct {
+	WMTableView *table;
+	WMFont *font;
+	GC gc;
+	GC selGC;
+	WMColor *textColor;
+} StringData;
+
+typedef struct {
+	WMTableView *table;
+	GC selGc;
+} PixmapData;
+
+typedef struct {
+	WMTextField *widget;
+	WMTableView *table;
+	WMFont *font;
+	GC gc;
+	GC selGC;
+	WMColor *textColor;
+} StringEditorData;
+
+typedef struct {
+	WMPopUpButton *widget;
+	WMTableView *table;
+	WMFont *font;
+	char **options;
+	int count;
+	GC gc;
+	GC selGC;
+	WMColor *textColor;
+} EnumSelectorData;
+
+typedef struct {
+	WMButton *widget;
+	WMTableView *table;
+	Bool state;
+	GC gc;
+	GC selGC;
+} BooleanSwitchData;
+
+static char *SelectionColor = "#bbbbcc";
+
+static void
+stringDraw(WMScreen * scr, Drawable d, GC gc, GC sgc, WMColor * textColor,
+	   WMFont * font, void *data, WMRect rect, Bool selected)
+{
+	int x, y;
+	XRectangle rects[1];
+	Display *dpy = WMScreenDisplay(scr);
+
+	x = rect.pos.x + 5;
+	y = rect.pos.y + (rect.size.height - WMFontHeight(font)) / 2;
+
+	rects[0].x = rect.pos.x + 1;
+	rects[0].y = rect.pos.y + 1;
+	rects[0].width = rect.size.width - 1;
+	rects[0].height = rect.size.height - 1;
+	XSetClipRectangles(dpy, gc, 0, 0, rects, 1, YXSorted);
+
+	if (!selected) {
+		XFillRectangles(dpy, d, gc, rects, 1);
+
+		WMDrawString(scr, d, textColor, font, x, y, data, strlen(data));
+	} else {
+		XFillRectangles(dpy, d, sgc, rects, 1);
+
+		WMDrawString(scr, d, textColor, font, x, y, data, strlen(data));
+	}
+
+	XSetClipMask(dpy, gc, None);
+}
+
+static void pixmapDraw(WMScreen * scr, Drawable d, GC gc, GC sgc, WMPixmap * pixmap, WMRect rect, Bool selected)
+{
+	int x, y;
+	XRectangle rects[1];
+	Display *dpy = WMScreenDisplay(scr);
+	WMSize size;
+
+	rects[0].x = rect.pos.x + 1;
+	rects[0].y = rect.pos.y + 1;
+	rects[0].width = rect.size.width - 1;
+	rects[0].height = rect.size.height - 1;
+	XSetClipRectangles(dpy, gc, 0, 0, rects, 1, YXSorted);
+
+	if (!selected) {
+		XFillRectangles(dpy, d, gc, rects, 1);
+
+		if (pixmap) {
+			size = WMGetPixmapSize(pixmap);
+			x = rect.pos.x + (rect.size.width - size.width) / 2;
+			y = rect.pos.y + (rect.size.height - size.height) / 2;
+
+			WMDrawPixmap(pixmap, d, x, y);
+		}
+	} else {
+		XFillRectangles(dpy, d, sgc, rects, 1);
+
+		if (pixmap) {
+			size = WMGetPixmapSize(pixmap);
+			x = rect.pos.x + (rect.size.width - size.width) / 2;
+			y = rect.pos.y + (rect.size.height - size.height) / 2;
+
+			WMDrawPixmap(pixmap, d, x, y);
+		}
+	}
+
+	XSetClipMask(dpy, gc, None);
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void SECellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	StringEditorData *strdata = (StringEditorData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+
+	stringDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC, strdata->textColor, strdata->font,
+		   WMTableViewDataForCell(table, column, row), WMTableViewRectForCell(table, column, row), False);
+}
+
+static void selectedSECellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	StringEditorData *strdata = (StringEditorData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+
+	stringDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC, strdata->textColor, strdata->font,
+		   WMTableViewDataForCell(table, column, row), WMTableViewRectForCell(table, column, row), True);
+}
+
+static void beginSECellEdit(WMTableColumnDelegate * self, WMTableColumn * column, int row)
+{
+	StringEditorData *strdata = (StringEditorData *) self->data;
+	WMRect rect = WMTableViewRectForCell(strdata->table, column, row);
+	void *data = WMTableViewDataForCell(strdata->table, column, row);
+
+	WMSetTextFieldText(strdata->widget, (char *)data);
+	WMMoveWidget(strdata->widget, rect.pos.x, rect.pos.y);
+	WMResizeWidget(strdata->widget, rect.size.width + 1, rect.size.height + 1);
+
+	WMMapWidget(strdata->widget);
+}
+
+static void endSECellEdit(WMTableColumnDelegate * self, WMTableColumn * column, int row)
+{
+	StringEditorData *strdata = (StringEditorData *) self->data;
+	char *text;
+
+	WMUnmapWidget(strdata->widget);
+
+	text = WMGetTextFieldText(strdata->widget);
+	WMSetTableViewDataForCell(strdata->table, column, row, (void *)text);
+}
+
+WMTableColumnDelegate *WTCreateStringEditorDelegate(WMTableView * parent)
+{
+	WMTableColumnDelegate *delegate = wmalloc(sizeof(WMTableColumnDelegate));
+	WMScreen *scr = WMWidgetScreen(parent);
+	StringEditorData *data = wmalloc(sizeof(StringEditorData));
+
+	data->widget = WMCreateTextField(parent);
+	W_ReparentView(WMWidgetView(data->widget), WMGetTableViewDocumentView(parent), 0, 0);
+	data->table = parent;
+	data->font = WMSystemFontOfSize(scr, 12);
+	data->gc = WMColorGC(WMWhiteColor(scr));
+	data->selGC = WMColorGC(WMCreateNamedColor(scr, SelectionColor, False));
+	data->textColor = WMBlackColor(scr);
+
+	delegate->data = data;
+	delegate->drawCell = SECellPainter;
+	delegate->drawSelectedCell = selectedSECellPainter;
+	delegate->beginCellEdit = beginSECellEdit;
+	delegate->endCellEdit = endSECellEdit;
+
+	return delegate;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void ESCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	EnumSelectorData *strdata = (EnumSelectorData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+	uintptr_t i = (uintptr_t)WMTableViewDataForCell(table, column, row);
+
+	stringDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC, strdata->textColor, strdata->font,
+		   strdata->options[i], WMTableViewRectForCell(table, column, row), False);
+}
+
+static void selectedESCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	EnumSelectorData *strdata = (EnumSelectorData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+	uintptr_t i = (uintptr_t)WMTableViewDataForCell(table, column, row);
+
+	stringDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC, strdata->textColor, strdata->font,
+		   strdata->options[i], WMTableViewRectForCell(table, column, row), True);
+}
+
+static void beginESCellEdit(WMTableColumnDelegate * self, WMTableColumn * column, int row)
+{
+	EnumSelectorData *strdata = (EnumSelectorData *) self->data;
+	WMRect rect = WMTableViewRectForCell(strdata->table, column, row);
+	uintptr_t data = (uintptr_t)WMTableViewDataForCell(strdata->table, column, row);
+
+	wassertr(data < strdata->count);
+
+	WMSetPopUpButtonSelectedItem(strdata->widget, data);
+
+	WMMoveWidget(strdata->widget, rect.pos.x, rect.pos.y);
+	WMResizeWidget(strdata->widget, rect.size.width, rect.size.height + 1);
+
+	WMMapWidget(strdata->widget);
+}
+
+static void endESCellEdit(WMTableColumnDelegate * self, WMTableColumn * column, int row)
+{
+	EnumSelectorData *strdata = (EnumSelectorData *) self->data;
+	int option;
+
+	WMUnmapWidget(strdata->widget);
+
+	option = WMGetPopUpButtonSelectedItem(strdata->widget);
+	WMSetTableViewDataForCell(strdata->table, column, row, (void *)(uintptr_t) option);
+}
+
+WMTableColumnDelegate *WTCreateEnumSelectorDelegate(WMTableView * parent)
+{
+	WMTableColumnDelegate *delegate = wmalloc(sizeof(WMTableColumnDelegate));
+	WMScreen *scr = WMWidgetScreen(parent);
+	EnumSelectorData *data = wmalloc(sizeof(EnumSelectorData));
+
+	data->widget = WMCreatePopUpButton(parent);
+	W_ReparentView(WMWidgetView(data->widget), WMGetTableViewDocumentView(parent), 0, 0);
+	data->table = parent;
+	data->font = WMSystemFontOfSize(scr, 12);
+	data->gc = WMColorGC(WMWhiteColor(scr));
+	data->selGC = WMColorGC(WMCreateNamedColor(scr, SelectionColor, False));
+	data->textColor = WMBlackColor(scr);
+	data->count = 0;
+	data->options = NULL;
+
+	delegate->data = data;
+	delegate->drawCell = ESCellPainter;
+	delegate->drawSelectedCell = selectedESCellPainter;
+	delegate->beginCellEdit = beginESCellEdit;
+	delegate->endCellEdit = endESCellEdit;
+
+	return delegate;
+}
+
+void WTSetEnumSelectorOptions(WMTableColumnDelegate * delegate, char **options, int count)
+{
+	EnumSelectorData *data = (EnumSelectorData *) delegate->data;
+	int i;
+
+	for (i = 0; i < WMGetPopUpButtonNumberOfItems(data->widget); i++) {
+		WMRemovePopUpButtonItem(data->widget, 0);
+	}
+
+	data->options = options;
+	data->count = count;
+
+	for (i = 0; i < count; i++) {
+		WMAddPopUpButtonItem(data->widget, options[i]);
+	}
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void BSCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	BooleanSwitchData *strdata = (BooleanSwitchData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+	uintptr_t i = (uintptr_t)WMTableViewDataForCell(table, column, row);
+	WMScreen *scr = WMWidgetScreen(table);
+
+	if (i) {
+		pixmapDraw(scr, d,
+			   strdata->gc, strdata->selGC, WMGetSystemPixmap(scr, WSICheckMark),
+			   WMTableViewRectForCell(table, column, row), False);
+	} else {
+		pixmapDraw(scr, d,
+			   strdata->gc, strdata->selGC, NULL, WMTableViewRectForCell(table, column, row), False);
+	}
+}
+
+static void selectedBSCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	BooleanSwitchData *strdata = (BooleanSwitchData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+	uintptr_t i = (uintptr_t)WMTableViewDataForCell(table, column, row);
+	WMScreen *scr = WMWidgetScreen(table);
+
+	if (i) {
+		pixmapDraw(scr, d,
+			   strdata->gc, strdata->selGC, WMGetSystemPixmap(scr, WSICheckMark),
+			   WMTableViewRectForCell(table, column, row), True);
+	} else {
+		pixmapDraw(scr, d,
+			   strdata->gc, strdata->selGC, NULL, WMTableViewRectForCell(table, column, row), True);
+	}
+}
+
+static void beginBSCellEdit(WMTableColumnDelegate * self, WMTableColumn * column, int row)
+{
+	BooleanSwitchData *strdata = (BooleanSwitchData *) self->data;
+	WMRect rect = WMTableViewRectForCell(strdata->table, column, row);
+	uintptr_t data = (uintptr_t)WMTableViewDataForCell(strdata->table, column, row);
+
+	WMSetButtonSelected(strdata->widget, data);
+	WMMoveWidget(strdata->widget, rect.pos.x + 1, rect.pos.y + 1);
+	WMResizeWidget(strdata->widget, rect.size.width - 1, rect.size.height - 1);
+
+	WMMapWidget(strdata->widget);
+}
+
+static void endBSCellEdit(WMTableColumnDelegate * self, WMTableColumn * column, int row)
+{
+	BooleanSwitchData *strdata = (BooleanSwitchData *) self->data;
+	int value;
+
+	value = WMGetButtonSelected(strdata->widget);
+	WMSetTableViewDataForCell(strdata->table, column, row, (void *)(uintptr_t) value);
+	WMUnmapWidget(strdata->widget);
+}
+
+WMTableColumnDelegate *WTCreateBooleanSwitchDelegate(WMTableView * parent)
+{
+	WMTableColumnDelegate *delegate = wmalloc(sizeof(WMTableColumnDelegate));
+	WMScreen *scr = WMWidgetScreen(parent);
+	BooleanSwitchData *data = wmalloc(sizeof(BooleanSwitchData));
+	WMColor *color;
+
+	data->widget = WMCreateSwitchButton(parent);
+	W_ReparentView(WMWidgetView(data->widget), WMGetTableViewDocumentView(parent), 0, 0);
+	WMSetButtonText(data->widget, NULL);
+	WMSetButtonImagePosition(data->widget, WIPImageOnly);
+	WMSetButtonImage(data->widget, NULL);
+	WMSetButtonAltImage(data->widget, WMGetSystemPixmap(scr, WSICheckMark));
+
+	data->table = parent;
+	color = WMCreateNamedColor(scr, SelectionColor, False);
+	WMSetWidgetBackgroundColor(data->widget, color);
+	data->gc = WMColorGC(WMWhiteColor(scr));
+	data->selGC = WMColorGC(color);
+
+	delegate->data = data;
+	delegate->drawCell = BSCellPainter;
+	delegate->drawSelectedCell = selectedBSCellPainter;
+	delegate->beginCellEdit = beginBSCellEdit;
+	delegate->endCellEdit = endBSCellEdit;
+
+	return delegate;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void SCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	StringData *strdata = (StringData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+
+	stringDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC, strdata->textColor, strdata->font,
+		   WMTableViewDataForCell(table, column, row), WMTableViewRectForCell(table, column, row), False);
+}
+
+static void selectedSCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	StringData *strdata = (StringData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+
+	stringDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC, strdata->textColor, strdata->font,
+		   WMTableViewDataForCell(table, column, row), WMTableViewRectForCell(table, column, row), True);
+}
+
+WMTableColumnDelegate *WTCreateStringDelegate(WMTableView * parent)
+{
+	WMTableColumnDelegate *delegate = wmalloc(sizeof(WMTableColumnDelegate));
+	WMScreen *scr = WMWidgetScreen(parent);
+	StringData *data = wmalloc(sizeof(StringData));
+
+	data->table = parent;
+	data->font = WMSystemFontOfSize(scr, 12);
+	data->gc = WMColorGC(WMWhiteColor(scr));
+	data->selGC = WMColorGC(WMCreateNamedColor(scr, SelectionColor, False));
+	data->textColor = WMBlackColor(scr);
+
+	delegate->data = data;
+	delegate->drawCell = SCellPainter;
+	delegate->drawSelectedCell = selectedSCellPainter;
+	delegate->beginCellEdit = NULL;
+	delegate->endCellEdit = NULL;
+
+	return delegate;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void PCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	StringData *strdata = (StringData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+
+	pixmapDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC,
+		   (WMPixmap *) WMTableViewDataForCell(table, column, row),
+		   WMTableViewRectForCell(table, column, row), False);
+}
+
+static void selectedPCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	StringData *strdata = (StringData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+
+	pixmapDraw(WMWidgetScreen(table), d,
+		   strdata->gc, strdata->selGC,
+		   (WMPixmap *) WMTableViewDataForCell(table, column, row),
+		   WMTableViewRectForCell(table, column, row), True);
+}
+
+WMTableColumnDelegate *WTCreatePixmapDelegate(WMTableView * table)
+{
+	WMTableColumnDelegate *delegate = wmalloc(sizeof(WMTableColumnDelegate));
+	WMScreen *scr = WMWidgetScreen(table);
+	StringData *data = wmalloc(sizeof(StringData));
+
+	data->table = table;
+	data->gc = WMColorGC(WMWhiteColor(scr));
+	data->selGC = WMColorGC(WMCreateNamedColor(scr, SelectionColor, False));
+
+	delegate->data = data;
+	delegate->drawCell = PCellPainter;
+	delegate->drawSelectedCell = selectedPCellPainter;
+	delegate->beginCellEdit = NULL;
+	delegate->endCellEdit = NULL;
+
+	return delegate;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void drawPSCell(WMTableColumnDelegate * self, Drawable d, WMTableColumn * column, int row, Bool selected)
+{
+	StringData *strdata = (StringData *) self->data;
+	WMTableView *table = WMGetTableColumnTableView(column);
+	void **data;
+	WMPixmap *pix;
+	char *str;
+	WMRect rect;
+	WMSize size;
+
+	data = WMTableViewDataForCell(table, column, row);
+
+	str = (char *)data[0];
+	pix = (WMPixmap *) data[1];
+
+	rect = WMTableViewRectForCell(table, column, row);
+
+	if (pix) {
+		int owidth = rect.size.width;
+
+		size = WMGetPixmapSize(pix);
+		rect.size.width = size.width;
+
+		pixmapDraw(WMWidgetScreen(table),
+			   WMViewXID(WMGetTableViewDocumentView(table)),
+			   strdata->gc, strdata->selGC, pix, rect, selected);
+
+		rect.pos.x += size.width - 1;
+		rect.size.width = owidth - size.width + 1;
+	}
+
+	stringDraw(WMWidgetScreen(table), d, strdata->gc, strdata->selGC,
+		   strdata->textColor, strdata->font, str, rect, selected);
+}
+
+static void PSCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	drawPSCell(self, d, column, row, False);
+}
+
+static void selectedPSCellPainter(WMTableColumnDelegate * self, WMTableColumn * column, int row, Drawable d)
+{
+	drawPSCell(self, d, column, row, True);
+}
+
+WMTableColumnDelegate *WTCreatePixmapStringDelegate(WMTableView * parent)
+{
+	WMTableColumnDelegate *delegate = wmalloc(sizeof(WMTableColumnDelegate));
+	WMScreen *scr = WMWidgetScreen(parent);
+	StringData *data = wmalloc(sizeof(StringData));
+
+	data->table = parent;
+	data->font = WMSystemFontOfSize(scr, 12);
+	data->gc = WMColorGC(WMWhiteColor(scr));
+	data->selGC = WMColorGC(WMCreateNamedColor(scr, SelectionColor, False));
+	data->textColor = WMBlackColor(scr);
+
+	delegate->data = data;
+	delegate->drawCell = PSCellPainter;
+	delegate->drawSelectedCell = selectedPSCellPainter;
+	delegate->beginCellEdit = NULL;
+	delegate->endCellEdit = NULL;
+
+	return delegate;
+}

bazel/WINGs/Extras/wtabledelegates.h

@@ -0,0 +1,25 @@
+
+#ifndef _TABLEDELEGATES_H_
+#define _TABLEDELEGATES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+WMTableColumnDelegate *WTCreatePixmapDelegate(WMTableView *table);
+WMTableColumnDelegate *WTCreateStringDelegate(WMTableView *table);
+WMTableColumnDelegate *WTCreatePixmapStringDelegate(WMTableView *parent);
+
+WMTableColumnDelegate *WTCreateStringEditorDelegate(WMTableView *table);
+
+WMTableColumnDelegate *WTCreateEnumSelectorDelegate(WMTableView *table);
+void WTSetEnumSelectorOptions(WMTableColumnDelegate *delegate,
+                              char **options, int count);
+
+WMTableColumnDelegate *WTCreateBooleanSwitchDelegate(WMTableView *parent);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

bazel/WINGs/Extras/wtableview.h

@@ -0,0 +1,121 @@
+
+
+
+#ifndef _WTABLEVIEW_H_
+#define _WTABLEVIEW_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct W_TableColumn WMTableColumn;
+typedef struct W_TableView WMTableView;
+
+
+extern const char *WMTableViewSelectionDidChangeNotification;
+
+
+typedef struct WMTableColumnDelegate {
+    void *data;
+    void (*drawCell)(struct WMTableColumnDelegate *self,
+                     WMTableColumn *column, int row, Drawable d);
+    void (*drawSelectedCell)(struct WMTableColumnDelegate *self,
+                             WMTableColumn *column, int row, Drawable d);
+
+    void (*beginCellEdit)(struct WMTableColumnDelegate *self, WMTableColumn *column,
+                          int row);
+    void (*endCellEdit)(struct WMTableColumnDelegate *self, WMTableColumn *column,
+                        int row);
+} WMTableColumnDelegate;
+
+
+typedef struct W_TableViewDelegate {
+    void *data;
+    int (*numberOfRows)(struct W_TableViewDelegate *self,
+                        WMTableView *table);
+    void *(*valueForCell)(struct W_TableViewDelegate *self,
+                          WMTableColumn *column, int row);
+    void (*setValueForCell)(struct W_TableViewDelegate *self,
+                            WMTableColumn *column, int row, void *value);
+} WMTableViewDelegate;
+
+
+
+
+
+WMTableColumn *WMCreateTableColumn(char *title);
+
+void WMSetTableColumnWidth(WMTableColumn *column, unsigned width);
+
+void WMSetTableColumnConstraints(WMTableColumn *column,
+                                 unsigned minWidth, unsigned maxWidth);
+
+void WMSetTableColumnDelegate(WMTableColumn *column,
+                              WMTableColumnDelegate *delegate);
+
+
+WMTableView *WMGetTableColumnTableView(WMTableColumn *column);
+
+void WMSetTableColumnId(WMTableColumn *column, void *id);
+
+void *WMGetTableColumnId(WMTableColumn *column);
+
+
+WMTableView *WMCreateTableView(WMWidget *parent);
+
+
+void WMSetTableViewDataSource(WMTableView *table, void *source);
+
+void *WMGetTableViewDataSource(WMTableView *table);
+
+void WMSetTableViewHeaderHeight(WMTableView *table, unsigned height);
+
+void WMAddTableViewColumn(WMTableView *table, WMTableColumn *column);
+
+void WMSetTableViewDelegate(WMTableView *table, WMTableViewDelegate *delegate);
+
+void WMSetTableViewAction(WMTableView *table, WMAction *action,
+                          void *clientData);
+
+void *WMGetTableViewClickedColumn(WMTableView *table);
+
+int WMGetTableViewClickedRow(WMTableView *table);
+
+WMArray *WMGetTableViewSelectedRows(WMTableView *table);
+
+WMView *WMGetTableViewDocumentView(WMTableView *table);
+
+void WMEditTableViewRow(WMTableView *table, int row);
+
+void WMSelectTableViewRow(WMTableView *table, int row);
+
+void *WMTableViewDataForCell(WMTableView *table, WMTableColumn *column,
+                             int row);
+
+void WMSetTableViewDataForCell(WMTableView *table, WMTableColumn *column,
+                               int row, void *data);
+
+WMRect WMTableViewRectForCell(WMTableView *table, WMTableColumn *column,
+                              int row);
+
+void WMSetTableViewBackgroundColor(WMTableView *table, WMColor *color);
+
+void WMSetTableViewGridColor(WMTableView *table, WMColor *color);
+
+void WMSetTableViewRowHeight(WMTableView *table, int height);
+
+void WMReloadTableView(WMTableView *table);
+
+void WMNoteTableViewNumberOfRowsChanged(WMTableView *table);
+
+void WMScrollTableViewRowToVisible(WMTableView *table, int row);
+
+void WMSetTableViewHasHorizontalScroller(WMTableView *tPtr, Bool flag);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

bazel/WINGs/Makefile.am

@@ -0,0 +1,119 @@
+## automake input file for WINGs
+
+AUTOMAKE_OPTIONS =
+
+SUBDIRS = WINGs . po Documentation Resources
+DIST_SUBDIRS = $(SUBDIRS) Tests Examples Extras
+
+libWINGs_la_LDFLAGS = -version-info @WINGS_VERSION@
+libWUtil_la_LDFLAGS = -version-info @WUTIL_VERSION@
+
+lib_LTLIBRARIES = libWUtil.la libWINGs.la
+
+
+LDADD= libWUtil.la libWINGs.la $(top_builddir)/wrlib/libwraster.la @INTLIBS@
+libWINGs_la_LIBADD = libWUtil.la $(top_builddir)/wrlib/libwraster.la @XLIBS@ @XFT_LIBS@ @FCLIBS@ @LIBM@ @PANGO_LIBS@
+libWUtil_la_LIBADD = @LIBBSD@
+
+EXTRA_DIST = BUGS make-rgb Examples Extras Tests
+
+
+# wbutton.c
+libWINGs_la_SOURCES = 	\
+	configuration.c \
+	dragcommon.c \
+	dragdestination.c \
+	dragsource.c \
+	rgb.h \
+	selection.c \
+	wappresource.c \
+	wballoon.c \
+	wbox.c \
+	wbrowser.c \
+	wbutton.c \
+	wcolor.c \
+	wcolorpanel.c \
+	wcolorwell.c \
+	wconfig.h \
+	wevent.c \
+	wfilepanel.c \
+	wframe.c \
+	wfont.c \
+	wfontpanel.c \
+	widgets.c \
+	winputmethod.c \
+	wlabel.c \
+	wlist.c \
+	wmenuitem.c \
+	wmisc.c \
+	wpanel.c \
+	wpixmap.c \
+	wpopupbutton.c \
+	wprogressindicator.c \
+	wruler.c \
+	wscroller.c \
+	wscrollview.c \
+	wslider.c \
+	wsplitview.c \
+	wtabview.c \
+	wtext.c \
+	wtextfield.c \
+	wview.c \
+	wwindow.c
+
+libWUtil_la_SOURCES = 	\
+	array.c \
+	bagtree.c \
+	data.c \
+	error.c \
+	error.h \
+	findfile.c \
+	handlers.c \
+	hashtable.c \
+	memory.c \
+	menuparser.c \
+	menuparser.h \
+	menuparser_macros.c \
+	misc.c \
+	notification.c \
+	proplist.c \
+	string.c \
+	tree.c \
+	userdefaults.c \
+	userdefaults.h \
+	usleep.c \
+	wapplication.c \
+	wconfig.h \
+	wutil.c
+
+
+AM_CFLAGS = @PANGO_CFLAGS@
+
+AM_CPPFLAGS = -DRESOURCE_PATH=\"$(datadir)/WINGs\" \
+	 -I$(top_srcdir)/WINGs/WINGs -I$(top_builddir)/WINGs/WINGs \
+	 -I$(top_builddir)/wrlib -I$(top_srcdir)/src \
+	@XFT_CFLAGS@ @HEADER_SEARCH_PATH@
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = WINGs.pc WUtil.pc
+
+DISTCLEANFILES = $(pkgconfig_DATA)
+
+WINGs.pc: Makefile
+	@echo "Generating $@"
+	@echo 'Name: WINGs' > $@
+	@echo 'Description: Small widget set with the NeXTStep(TM) look and feel' >> $@
+	@echo 'Version: $(VERSION)' >> $@
+	@echo 'Requires: wrlib WUtil' >> $@
+	@echo 'Libs: $(lib_search_path) -lWINGs' >> $@
+	@echo 'Libs.private: $(XFT_LIBS) $(PANGOLIBS) $(XLIBS) -lm $(INTLIBS)' >> $@
+	@echo 'Cflags: $(inc_search_path) @PANGO_CFLAGS@' >> $@
+
+WUtil.pc: Makefile
+	@echo "Generating $@"
+	@echo 'Name: WUtil' > $@
+	@echo 'Description: Utility library for WINGs' >> $@
+	@echo 'Version: $(VERSION)' >> $@
+	@echo 'Libs: -L$(libdir) -lWUtil' >> $@
+	@echo 'Libs.private: $(INTLIBS)' >> $@
+	@echo 'Cflags: -I$(includedir)' >> $@

bazel/WINGs/NEWS

@@ -0,0 +1,514 @@
+** API and ABI modifications since wmaker 0.96.0
+----------------------------------------------------
+
+** libWINGs **
+<WINGsP.h>
+W_KeycodeToKeysym ADDED
+struct W_DragDestinationInfo: new members added SIZE CHANGE
+
+<WINGs.h>
+WMGetTextFieldCursorPosition ADDED
+WC_Matrix REMOVED from enum.
+WMCreateProgressIndicator REMOVED
+WMSetProgressIndicatorMinValue REMOVED
+WMSetProgressIndicatorMaxValue REMOVED
+WMSetProgressIndicatorValue REMOVED
+WMGetProgressIndicatorMinValue REMOVED
+WMGetProgressIndicatorMaxValue REMOVED
+WMGetProgressIndicatorValue REMOVED
+typedef struct W_Ruler WMRuler REMOVED
+typedef struct WMRulerMargins REMOVED
+WMAppendTextBlock REMOVED
+WMAppendTextStream REMOVED
+WMCreateRuler  REMOVED
+WMCreateTextBlockWithObject REMOVED
+WMCreateTextBlockWithPixmap REMOVED
+WMCreateTextBlockWithText REMOVED
+WMCreateTextForDocumentType REMOVED
+WMDestroyTextBlock REMOVED
+WMFindInTextStream REMOVED
+WMFreezeText REMOVED
+WMGetGrabbedRulerMargin REMOVED
+WMGetReleasedRulerMargin REMOVED
+WMGetRulerMargins REMOVED
+WMGetRulerOffset REMOVED
+WMGetTextBlockProperties REMOVED
+WMGetTextDefaultColor REMOVED
+WMGetTextDefaultFont REMOVED
+WMGetTextEditable REMOVED
+WMGetTextIgnoresNewline REMOVED
+WMGetTextInsertType REMOVED
+WMGetTextObjects REMOVED
+WMGetTextRulerShown REMOVED
+WMGetTextSelectedObjects REMOVED
+WMGetTextSelectedStream REMOVED
+WMGetTextSelectionColor REMOVED
+WMGetTextSelectionFont REMOVED
+WMGetTextSelectionUnderlined REMOVED
+WMGetTextStream REMOVED
+WMGetTextUsesMonoFont REMOVED
+WMIsMarginEqualToMargin REMOVED
+WMPageText REMOVED
+WMPrependTextBlock REMOVED
+WMPrependTextStream REMOVED
+WMRemoveTextBlock REMOVED
+WMReplaceTextSelection REMOVED
+WMScrollText REMOVED
+WMSetRulerMargins REMOVED
+WMSetRulerMoveAction REMOVED
+WMSetRulerOffset REMOVED
+WMSetRulerReleaseAction REMOVED
+WMSetTextAlignment REMOVED
+WMSetTextBackgroundColor REMOVED
+WMSetTextBackgroundPixmap REMOVED
+WMSetTextBlockProperties REMOVED
+WMSetTextDefaultColor REMOVED
+WMSetTextDefaultFont REMOVED
+WMSetTextDelegate REMOVED
+WMSetTextEditable REMOVED
+WMSetTextForegroundColor REMOVED
+WMSetTextHasHorizontalScroller REMOVED
+WMSetTextHasRuler REMOVED
+WMSetTextHasVerticalScroller REMOVED
+WMSetTextIgnoresNewline REMOVED
+WMSetTextIndentNewLines REMOVED
+WMSetTextRelief REMOVED
+WMSetTextSelectionColor REMOVED
+WMSetTextSelectionFont REMOVED
+WMSetTextSelectionUnderlined REMOVED
+WMSetTextUsesMonoFont REMOVED
+WMShowTextRuler REMOVED
+WMThawText REMOVED
+WMRefreshText REMOVED
+WMCreateText REMOVED
+WMClearText REMOVED
+
+
+
+
+** libWutil **
+enum WMConnectionState REMOVED
+enum WMConnectionTimeoutState REMOVED
+struct ConnectionDelegate REMOVED
+__wmessage ADDED
+wstrerror REMOVED
+wmessage converted from function to wrapper macro
+wwarning converted from function to wrapper macro
+wfatal converted from function to wrapper macro
+wsyserror converted from function to wrapper macro
+wsyserror REMOVED (use werror instead)
+werror macro ADDED (replaces wsyserror)
+wsyserrorwithcode removed
+wmkdirhier ADDED
+wrmdirhier ADDED
+wmalloc0 REMOVED
+wnew REMOVED
+wnew0 REMOVED
+wstrlcpy ADDED
+wstrlcat ADDED
+WMPushInArray REMOVED
+WMWritePropListToFile NUMBER OF FUNCTION ARGUMENTS CHANGED
+WMGetCurrentHost
+WMGetHostWithName
+WMGetHostWithAddress
+WMRetainHost
+WMReleaseHost
+WMSetHostCacheEnabled
+WMIsHostCacheEnabled
+WMFlushHostCache
+WMIsHostEqualToHost
+WMGetHostName
+WMGetHostNames
+WMGetHostAddress
+WMCreateConnectionAsServerAtAddress REMOVED
+WMCreateConnectionToAddress REMOVED
+WMCreateConnectionToAddressAndNotify REMOVED
+WMCloseConnection REMOVED
+WMDestroyConnection REMOVED
+WMConnection* WMAcceptConnection REMOVED
+WMGetConnectionAvailableData REMOVED
+WMSendConnectionData REMOVED
+WMEnqueueConnectionData REMOVED
+WMFlushConnection REMOVED
+WMSetConnectionDelegate REMOVED
+WMGetConnectionService REMOVED
+WMGetConnectionProtocol REMOVED
+WMSetConnectionNonBlocking REMOVED
+WMSetConnectionCloseOnExec REMOVED
+WMSetConnectionShutdownOnClose REMOVED
+WMGetConnectionClientData REMOVED
+WMSetConnectionClientData REMOVED
+WMGetConnectionFlags REMOVED
+WMSetConnectionFlags REMOVED
+WMGetConnectionSocket REMOVED
+WMGetConnectionState REMOVED
+WMGetConnectionTimeoutState REMOVED
+WMGetConnectionUnsentData REMOVED
+WMGetConnectionQueuedData REMOVED
+WMSetConnectionDefaultTimeout REMOVED
+WMSetConnectionOpenTimeout REMOVED
+WMSetConnectionSendTimeout REMOVED
+
+WMTreeWalkProc ADDED
+WMTreeWalk ADDED
+wshellquote ADDED
+
+
+
+----------------------------------------------------
+
+*** Fri May 15 18:44:50 CEST 2015 - Christophe
+
+New Tri-state type for WMButton
+-------------------------------
+
+A new check-box type button is available with state On/Off/Tri, the later being
+generally used to express "leave as-is". The states are cycled through as user
+click on the button. It is created with:
+  btn = WMCreateButton(parent_widget, WBTTriState);
+
+There are is this case 3 possible values for WMSetButtonSelected/WMGetButtonSelected:
+ - 0 and 1, the legacy checked/unchecked states
+ - the new -1, when in the 3rd state
+
+
+*** Sun Dec  7 10:52:21 CET 2014 - David
+
+Support for pixmap in the background of Widget
+----------------------------------------------
+
+The new function WMSetWidgetBackgroundPixmap was introduced to specify a pixmap
+that will be displayed as the background of a widget instead of the usual plain
+color. The dual WMGetWidgetBackgroundPixmap is provided too.
+
+
+*** Sun Nov  2 13:04:14 CET 2014 - David
+
+Get the text of a button
+------------------------
+
+It was assumed that there was no need to retrieve the text from a button because
+it is generally a static constant text, but there are some cases where this can
+be useful, so the new function WMGetButtonText was added to the API.
+
+
+*** Thu May  9 18:24:03 CEST 2013 - Christophe
+
+Const-correctness API changes for WRaster, WUtils and WINGs
+-----------------------------------------------------------
+
+The 3 libraries have been modified to include appropriate 'const' qualifier
+to the function parameters that are treated as such. This should provide
+some hints to the compiler for better optimisation.
+This change should have no impact on the binary interface, and will not
+impact existing source code.
+
+There is one exception however:
+   WUtil: wusergnusteppath()
+This function now returns 'const char *' because its result must *not* be
+modified, so it may generate a const related warning in old code.
+
+
+*** Fri Mar  7 00:39:28 CET 2014 - David
+
+New function WMCreateScaledBlendedPixmapFromFile
+------------------------------------------------
+
+This function can load an image from a file and if it is bigger than the
+specified width/height then it will be scaled down to fit the size while
+keeping the aspect ratio of the original image.
+
+
+*** Mon Oct 14 19:42:42 EEST 2002 - Dan
+
+Double buffering
+----------------
+
+To avoid flickering caused by redrawing the widgets on Expose events, a
+double buffering technique was implemented for most of the widgets.
+This flickering effect has gotten more visible with the introduction
+of antialiased fonts. If with normal text one can redraw the text over the
+old one over and over again without any degradation of the text (new pixels
+simply overwrite old pixels), with antialiased text the situation is
+different and text gets quickly corrupted. To avoid this corruption, one
+needs to first erase the area where the text will go, which can cause the
+before mentioned flickering.
+The double buffer is implemented to solve this issue.
+
+This is a change that that will be automatically available for any WINGs
+applications and will require no change in the existing code.
+However there is an exception from this in case of WMList if you delegate
+the drawing of items to userspace (read below for the complete details).
+
+
+*** Mon Oct 14 22:07:42 EEST 2002 - Dan
+
+WMList change
+-------------
+
+In case of WMList there is the possibility to delegate the drawing of the
+list items to the application that is linked with WINGs, and this code will
+not be inside the WINGs library, but in userland. Since we use the double
+buffering technique in this case too (to allow all widgets based on WMList
+and the ones that draw their list items by themselves to benefit from the
+double buffering advantage automatically), we no longer pass the window to
+the user code doing item drawing, but instead pass this pixmap in which we
+draw before copying to the real window.
+
+Since one cannot use XClearWindow() or XClearArea() on pixmaps, but only on
+windows, if the code drawing list items used to call these functions to clear
+the item area before drawing it needs to change to using XFillRectangle()
+instead.
+
+With this change it also means that there is no longer any need to do any
+double buffering in the user code, since it's already done by WINGs.
+
+
+*** Mon Oct 14 19:28:35 EEST 2002 - Dan
+
+API change
+----------
+
+WMDrawString() and WMDrawImageString() no longer take a GC as argument.
+Instead WMDrawString() takes a WMColor* as the color for the string to be
+drawn, while WMDrawImageString() takes 2 WMColor* arguments in place of the
+old GC: first for text color and second for background color.
+
+This change is required to support extending WMFont to allow it to handle
+antialiased fonts through the XFree86 Xft2 extension.
+
+This also has the advantage of hiding low level X11 details and use WINGs
+internal objects instead.
+
+To fix your old code to work with the new WINGs API you need to replace the
+GC passed to WMDraw***String() in your code with a WMColor*.
+Most of the old code used to be like this:
+
+WMDrawString(screen, window, WMColorGC(color), font, x, y, txt, len);
+
+for the new API it should be replaced by:
+
+WMDrawString(screen, window, color, font, x, y, txt, len);
+
+However if you used a particular GC created by yourself to suit your special
+needs, you need to pass a color which is the same as the foreground color of
+that gc.
+
+For WMDrawImageString(), from:
+
+WMDrawImageString(screen, window, gc, font, x, y, txt, len);
+
+becomes
+
+WMDrawImageString(screen, window, textColor, backColor, font, x, y, txt, len);
+
+where textColor and backColor are declared like:
+
+WMColor *textColor, *backColor;
+
+and have the color of the foreground respective the background of the old gc.
+
+
+
+*** Wed Oct  9 07:10:04 EEST 2002 - Dan
+
+Antialiased font support
+------------------------
+
+With the addition of Xft2 support in the WINGs library, now WINGs can display
+antialiased text with TrueType or any scalable fonts.
+
+Antialiased text is enabled by default, but can be disabled by adding
+
+AntialiasedText = NO; in ~/GNUstep/Defaults/WMGLOBAL
+
+This will disable antialiased text for any WINGs based application. If you
+only want to disable them for a specific application only, like WindowMaker
+for example, then add the same option in the applications configuration file,
+in this case ~/GNUstep/Defaults/WindowMaker
+
+Note that bitmapped fonts look much better than TrueType when antialiasing is
+disabled.
+
+
+*** Mon Sep 09 06:58:30 EEST 2002 - Dan
+
+New delegate for the WMConnection class
+---------------------------------------
+
+ConnectionDelegate structure has a new member: canResumeSending.
+The purpose of this callback is to notify you that you can resume sending
+data over a WMConnection.
+It works in the following manner:
+
+WMSendConnectionData() can return 3 values: -1, 0, 1
+
+-1 - means that the connection has died. you should stop sending data and
+     close the connection ASAP.
+ 1 - means that the data was successfully sent
+ 0 - means that the data (or part of it) was not sent. however, it was saved
+     in a queue and the library will try to send it later when possible.
+
+if the return value is 1, you can continue to send the next message, and so
+on, until the return value of such a send call will be 0.
+After it returns 0 you can continue sending, however, the data will not be
+sent over the connection because the operating system cannot accept any more
+data for the moment. Instead it will be queued inside the library, making your
+program's memory footprint increase. If the amount of data you need to
+send is limited and not too big, this shouldn't be a problem, because your
+data will be queued and sent when the operating system will notify the
+library that sending is possible again.
+If this is the case you can just ignore the output of WMSendConnectionData()
+and not set a callback for canResumeSending.
+
+However, if the amount of data you have to send is undetermined and you
+also want to keep a small memory footprint for your program (so that it
+won't grow until it uses all your available memory ;) ), you will have to
+stop sending data over the connection as soon as WMSendConnectionData()
+returns with 0. Then you should somehow mark this situation in your program
+to avoid it trying to send anymore data until notified that it can resume.
+(You should have also set a canResumeSending callback when you initialized
+your WMConnection object because else you cannot be notified when to resume.)
+
+Now, when you receive such a 0 from the send operation, your last sent data
+is put in a queue inside the library. At a later time when the operating
+system notifies the library that sending is possible again, the library will
+resume to send the data that is saved in the queue. After it will be able to
+send all the data in the queue, the canResumeSending callback will be
+called, letting you know that not only you can resume sending because the
+operating system is again able to send data, but also that the queue was
+completely flushed.
+
+From the canResumeSending callback, you should again update the status of
+your program marking that it can send again, and then resume sending the
+data from where you were left.
+
+
+*** Thu Oct 04 06:00:09 EEST 2001 -Dan
+
+Property lists handling code
+----------------------------
+
+Code to handle property lists was added to WINGs. It is more robust
+than the libPropList code, mostly because some conflicting concepts
+borrowed from UserDefaults (which libPropList use) are no longer used in
+the WINGs property lists code. These borrowed concepts conflicted with the
+retain/release mechanism of property lists and could lead in certain cases
+to segmentation faults when executing libPropList based code. But the worse
+part was that these libPropList problems were practically unsolvable without
+removing one of those conflicting concepts and without a complete redesign.
+The new WINGs property lists code is also better integrated with the other
+data types from WINGs and is actively maintained.
+
+Practically the things that were removed from the WINGs property list
+implementation compared to the old libPropList implementation, are exactly
+the UserDefaults borrowed concepts that conflict with the retain/release
+mechanism:
+- The container of a proplist object and the associated functions are gone.
+- The filename associated with a proplist object and the corresponding
+  functions are gone. Now the saving function needs the filename as a
+  parameter.
+- The synchronization functions are no longer supported. They are part of
+  the UserDefaults and are implemented there.
+- No functions related to domains/registering were implemented in the WINGs
+  property lists code, because they are also not part of property lists.
+  They are more in connection with UserDefaults and a central point of access
+  for domains.
+
+The above 2 concepts: container and filename were added to libPropList just
+to let it support synchronization which was borrowed from UserDefaults.
+Property lists as defined in the openstep specification are just complex
+data structures composed of strings, data, arrays, dictionaries and a mix of
+them and are not associated with any file in particular. UserDefaults on the
+other hand are property lists read from a specific file and they associate
+that property list with that file and allow them to be synchronized.
+
+Old libPropList based code can still be used by linking against the WINGs
+library containing the new proplist code with minimal changes which are
+described in detail in the comments at the top of the WINGs/proplist-compat.h
+header file (the same file carries the #defines for mapping old libPropList
+functions to the new WINGs proplist functions).
+Our recommendation is to move to the new functions WINGs provide because
+they better integrate with other function naming conventions in WINGs.
+The proplist-compat.h header file is just a way to have old code up and
+running with minimal changes so that we can remove the old and unmaintained
+libPropList from systems while keeping to use old libPropList based code
+without rewriting it and it should not be used for other purposes.
+
+
+*** Sat Apr 21 09:12:09 EEST 2001 -Dan
+
+API change
+----------
+
+To allow a correct display of icon images with alpha blending in panels and
+other places where a WINGs based application may use them the following
+changes took place:
+
+1. The following functions were renamed:
+   - WMSetApplicationIconImage()  --> WMSetApplicationIconPixmap()
+   - WMGetApplicationIconImage()  --> WMGetApplicationIconPixmap()
+   - WMSetWindowMiniwindowImage() --> WMSetWindowMiniwindowPixmap()
+2. The following functions were added:
+   - WMSetApplicationIconImage(WMScreen *scr, RImage *image)
+   - RImage* WMGetApplicationIconImage(WMScreen *scr)
+   - WMPixmap* WMCreateApplicationIconBlendedPixmap(WMScreen *scr, RColor *col)
+
+As you can see the old functions that operated on WMPixmap images (which are
+basically X Pixmaps that lack alpha information) were renamed to ...Pixmap()
+to make them more suggestive about what they do and to make room for the
+new functions that operate on RImages (that hold alpha information).
+
+Since the corresponding WMGet... functions only retrieve the stored
+image/pixmap from the application, I'll outline how the WMSet...
+functions operate:
+
+All WM...IconPixmap() functions operate on WMPixmaps
+All WM...IconImage() functions operate on RImages
+
+
+- WMSetApplicationIconImage() will set the RImage to be used in panels
+    and will also convert the RImage to a WMPixmap with a threshold of 128
+    and will use that pixmap for the appicon image. If that doesn't satisfy
+    you, you can make a call to WMSetApplicationIconPixmap() on your own to
+    set whatever WMPixmap you see fit for the appicon.
+
+- WMSetApplicationIconPixmap() will set the WMPixmap to be used for the
+    appicon and for the panels
+
+
+If you use only one of the above functions, the corresponding image/pixmap
+will be used everywhere where needed (panels and appicon), but the pixmap
+version will not be able to handle alpha blending correctly.
+
+If you use both WMSetApplicationIconImage() and WMSetApplicationIconPixmap()
+then the RImage will have priority in panels, and the WMPixmap will only be
+used for the appicon. This allows you to better control what icon is
+displayed in the appicon, in case the default conversion of the RImage to a
+pixmap with a threshold of 128 is not good enough, or in case you want a
+different icon to be shown in the appicon than in panels.
+
+
+Also this new function was added:
+
+- WMCreateApplicationIconBlendedPixmap() will use the RImage set with
+    WMSetApplicationIconImage() if available and will blend it with the color
+    you passed. This will make the image show well on a background of that
+    color. If the RImage was not set it will return NULL. You need to call
+    WMReleasePixmap() on it after you finish with it. Passing a NULL pointer
+    instead of a color will make the RImage be blended with the default color
+    of the WINGs widgets: '#aeaaae' making it suitable to be assigned to any
+    WINGs widget.
+
+
+To make your existing code work as before all you need to do is to rename
+the following functions:
+
+   - WMSetApplicationIconImage()  --> WMSetApplicationIconPixmap()
+   - WMGetApplicationIconImage()  --> WMGetApplicationIconPixmap()
+   - WMSetWindowMiniwindowImage() --> WMSetWindowMiniwindowPixmap()
+
+But if you want to take advantage of the new abilities to show alpha
+blended images you need to start using the new functions.
+
+

bazel/WINGs/README

@@ -0,0 +1,97 @@
+
+                      WINGs - WINGs Is Not GNUstep
+
+                                   by
+
+                          Alfredo Kengi Kojima
+
+                          kojima@windowmaker.info
+
+
+   WINGs is a small widget set with the N*XTSTEP look and feel. Its API
+is inspired in OpenStep and its implementation borrows some ideas
+from Tk. It has a reasonable set of widgets, sufficient for building
+small applications (like a CDPlayer or hacking something like rxvt). It
+also has other functions that are usefull for applications, like a
+User Defaults alike configuration manager and a notification system.
+
+   The library is limited and its design is a little sloppy,
+so it's not intended to build large or complex applications, like
+anything more complex than a CDPlayer. GNUstep should be used for such
+applications.
+
+   Since WINGs is written in C and is sort of low-level it is small
+and faster than say, Motif or even Athena. Knowing Xlib will help you to
+workaround some of its limitations, although you'll probably be able to
+write something like a trivial tic-tac-toe game without knowing much Xlib.
+
+   Some of its functions are designed to support the Window Maker window
+manager (see http://windowmaker.info) In fact, its primary role is to
+support Window Maker. All other uses of it are just an added bonus.
+
+   It will help you to understand the API if you read the ApplicationKit
+reference manual, distributed as a PDF by Apple. The function names,
+structs and most of the intrinsics are very close to OpenStep classes.
+
+
+Internationalization:
+---------------------
+
+    Change ~/GNUstep/Defaults/WMGLOBAL to set the desired font set and
+set MultiByteText = YES; to enable support for multibyte text.
+
+
+Widgets provided by WINGs:
+--------------------------
+
+- button (command button, radio, switch etc. - all buttons defined in OpenStep)
+- label
+- textfield
+- frame
+- window
+- popup menu button
+- scroller
+- selection list
+- browser
+- slider
+- scrollable view
+- color well
+- split view
+- tabbed view
+- progress indicator
+
+- selection (make pasteboard like?)
+- drag&drop
+
+- input box
+- file panel
+- color panel
+- alert panel
+- font panel
+
+If you think you can code the following, please do. They are needed by
+WPrefs.app, but the number of other things I have to do is huge.
+
+- input method support (XIM). I have no idea of how to code it. People who use
+different characters than ASCII will have trouble editing menus without it...
+
+
+Wish list: (I don't have the know-how or time to do them)
+---------------------------------------------------------
+
+- text (with support for RTF)
+- matrix (like NSMatrix)
+- font manager (like NSFontManager)
+- finish other wigets
+- optimize list scrolling (XCopyArea() the area that's already drawn)
+- InterfaceMaker?
+- use XSetWMName and XSetWMIconName for the window/icon title setting.
+  This requires transforming the received text to a text property with
+  the proper encoding.
+
+Copyright
+---------
+
+WINGs is copyright (c) Alfredo K. Kojima and is licensed through the GNU
+Library General Public License (LGPL).
+

bazel/WINGs/Resources/Makefile.am

@@ -0,0 +1,6 @@
+
+resdatadir = $(datadir)/WINGs
+
+resdata_DATA = Images.tiff Images.xpm defaultIcon.tiff defaultIcon.xpm
+
+EXTRA_DIST = $(resdata_DATA) Images.xcf

bazel/WINGs/Resources/defaultIcon.xpm

@@ -0,0 +1,54 @@
+/* XPM */
+static char * defaultIcon_xpm[] = {
+"48 48 3 1",
+" 	c #000000000000",
+".	c None",
+"X	c #FFFFFFFFFFFF",
+"                                              ..",
+"                                              ..",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  ..",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  ..",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
+"                                                ",
+"                                                ",
+"....                                            ",
+"....                                            "};

bazel/WINGs/TODO

@@ -0,0 +1,14 @@
+- move paint to idle handlers
+- check if its useful to add some WMBrowserSelectionDidChangeNotification
+  (actually a pass-through for WMListSelectionDidChangeNotification).
+  Or a delegate to be called when the list selection change.
+- add some way to modify speed when scrolling WMList, depending on how
+  far the mouse is moved outside of the list.
+- clean up header files of declared but not implemented anywhere functions
+- implement a generic WMChangeFontAttribute(WMFont *font, enum attributes)
+  function
+
+
+- optimize color allocation for repeated colors
+- make it work in 8bpp
+- optimize SystemFont allocation for repeated font sizes

bazel/WINGs/Tests/Makefile.am

@@ -0,0 +1,21 @@
+## automake input file for WINGs - Tests
+
+AUTOMAKE_OPTIONS =
+
+noinst_PROGRAMS = wtest wmquery wmfile testmywidget
+
+LDADD= $(top_builddir)/WINGs/libWINGs.la $(top_builddir)/wrlib/libwraster.la \
+	$(top_builddir)/WINGs/libWUtil.la \
+	@XFT_LIBS@ @INTLIBS@ @XLIBS@
+
+
+testmywidget_SOURCES = testmywidget.c mywidget.c mywidget.h
+
+wtest_DEPENDENCIES = $(top_builddir)/WINGs/libWINGs.la
+
+
+EXTRA_DIST = logo.xpm upbtn.xpm wm.html wm.png
+
+AM_CPPFLAGS = -I$(top_srcdir)/WINGs -I$(top_srcdir)/wrlib -I$(top_srcdir)/src \
+	-DRESOURCE_PATH=\"$(datadir)/WINGs\" @XFT_CFLAGS@ @HEADER_SEARCH_PATH@ \
+	@PANGO_CFLAGS@

bazel/WINGs/Tests/logo.xpm

@@ -0,0 +1,56 @@
+/* XPM */
+static char * GNUSTEP_XPM[] = {
+"45 45 8 1",
+" 	c None",
+".	c #666666666666",
+"X	c #777777777777",
+"o	c #596559656185",
+"O	c #000000000000",
+"+	c #3CF33CF33CF3",
+"@	c #CF3CCF3CCF3C",
+"#	c #FFFFFFFFFFFF",
+"                                             ",
+"                .Xooooooooo.                 ",
+"            ..ooOOOOOOOOOOOOOo.              ",
+"          .XoOOOOOOOOOOOOOOOOOO+             ",
+"         .oOOOOOOOOOOOOOOOOOOOOOO+           ",
+"        XOOOOOOOOOOOOOOOOOOOOOOOOOOo         ",
+"       oOOOOOOOOOOOOOOOOOOOOOOOOOOOO+        ",
+"      oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO+ooooooo",
+"     +OOOOOOOOOOOOOOOOOOOOOOOOoXXXXX.XOOOOOOO",
+"    XOOOOOOOOOOOOOOOOOOOOOOOOOX#######.OOOOOO",
+"   XOOOOOOOOOOOOOOOOOOOOOOOOOOX########oOOOOO",
+"   OOOOOOOOOOOOOOOOOOOOOOOOOOOX#########oOOOO",
+"  oOOOOOOOOOOOOOOOOOOOOOOOOOOOX#########@OOOO",
+"  OOOOOOOOOOOOOOOOOOOOOOOOOOOOX##########oOOO",
+" oOOOOOOOOOOOOOOOOOOOOOOOOOOOOX##########@OOO",
+" OOOOOOOOOOOOOOOOOOOOOOOOOOOOOX###########+OO",
+" OOOOOOOOOOOOOOOOOOOOOOOOOOOOOX###########oOO",
+"oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX###########@OO",
+"+OOOOOOOOOOOOOOOOOOOOOOOOOOOOOX###########@OO",
+"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX############XO",
+"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX############XO",
+"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX############XO",
+"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX############XO",
+"OOOOOOOOOOOOOOOoX.X.X.X.XX.XXX@############XO",
+"OOOOOOOOOOOOOOOX###########################XO",
+"OOOOOOOOOOOOOOOX###########################XO",
+"OOOOOOOOOOOOOOOX###########################XO",
+"+OOOOOOOOOOOOOOX###########################OO",
+"oOOOOOOOOOOOOOOX###########################OO",
+" OOOOOOOOOOOOOOX##########################XOO",
+" OOOOOOOOOOOOOOX##########################oOO",
+" oOOOOOOOOOOOOOX#########################@OOO",
+"  OOOOOOOOOOOOOX#########################+OOO",
+"  oOOOOOOOOOOOOX########################@OOOO",
+"   OOOOOOOOOOOOX########################oOOOO",
+"    OOOOOOOOOOOX#######################oOOOOO",
+"     OOOOOOOOOOX######################XOOOOOO",
+"OOOOOOOXXXXXXXX@#####################@OOOOOOO",
+"OOOOOOOo############################@OOOOOOOO",
+"OOOOOOOOO@#########################oOOOOOOOOO",
+"OOOOOOOOOOX######################@oOOOOOOOOOO",
+"OOOOOOOOOOOOX###################XOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOX@#############@XOOOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOOOOXXX#####XXXOOOOOOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"};

bazel/WINGs/Tests/mywidget.c

@@ -0,0 +1,198 @@
+/*
+ * Demo user widget for WINGs
+ *
+ * Author: Alfredo K. Kojima
+ *
+ * This file is in the public domain.
+ *
+ */
+
+/*
+ *
+ * Include the WINGs private data header.
+ *
+ *
+ */
+#include <WINGs/WINGsP.h>
+
+/*
+ * Our public header.
+ */
+#include "mywidget.h"
+
+/*
+ * Define the widget "class"
+ */
+typedef struct W_MyWidget {
+	/* these two fields must be present in all your widgets in this
+	 * exact position */
+	W_Class widgetClass;
+	WMView *view;
+
+	/* put your stuff here */
+	char *text;
+
+} _MyWidget;
+
+/* some forward declarations */
+
+static void destroyMyWidget(_MyWidget * mPtr);
+static void paintMyWidget(_MyWidget * mPtr);
+
+static void handleEvents(XEvent * event, void *data);
+static void handleActionEvents(XEvent * event, void *data);
+
+/*
+ * Delegates
+ * See the source for the other widgets to see how to use.
+ * You won't need to use this most of the time.
+ */
+static W_ViewDelegate _MyWidgetDelegate = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+/* our widget class ID */
+static W_Class myWidgetClass = 0;
+
+/*
+ * Initializer for our widget. Must be called before creating any
+ * instances of the widget.
+ */
+W_Class InitMyWidget(WMScreen * scr)
+{
+	(void)scr;
+	/* register our widget with WINGs and get our widget class ID */
+	if (!myWidgetClass) {
+		myWidgetClass = W_RegisterUserWidget();
+	}
+
+	return myWidgetClass;
+}
+
+/*
+ * Our widget fabrication plant.
+ */
+MyWidget *CreateMyWidget(WMWidget * parent)
+{
+	MyWidget *mPtr;
+
+	/* allocate some storage for our new widget instance */
+	mPtr = wmalloc(sizeof(MyWidget));
+	/* initialize it */
+	memset(mPtr, 0, sizeof(MyWidget));
+
+	/* set the class ID */
+	mPtr->widgetClass = myWidgetClass;
+
+	/*
+	 * Create the view for our widget.
+	 * Note: the Window for the view is only created after the view is
+	 * realized with W_RealizeView()
+	 *
+	 * Consider the returned view as read-only.
+	 */
+	mPtr->view = W_CreateView(W_VIEW(parent));
+	if (!mPtr->view) {
+		wfree(mPtr);
+		return NULL;
+	}
+	/* always do this */
+	mPtr->view->self = mPtr;
+
+	/* setup the delegates for the view */
+	mPtr->view->delegate = &_MyWidgetDelegate;
+
+	/*
+	 * Intercept some events for our widget, so that we can handle them.
+	 */
+	WMCreateEventHandler(mPtr->view, ExposureMask	/* this allows us to know when we should paint */
+			     | StructureNotifyMask,	/* this allows us to know things like when we are destroyed */
+			     handleEvents, mPtr);
+
+	/*
+	 * Intercept some other events. This could be merged with the above
+	 * call, but we separate for more organization.
+	 */
+	WMCreateEventHandler(mPtr->view, ButtonPressMask, handleActionEvents, mPtr);
+
+	return mPtr;
+}
+
+/*
+ * Paint our widget contents.
+ */
+static void paintMyWidget(_MyWidget * mPtr)
+{
+	W_Screen *scr = mPtr->view->screen;
+	WMColor *color;
+
+	if (mPtr->text) {
+
+		color = WMWhiteColor(scr);
+
+		W_PaintText(mPtr->view, mPtr->view->window, scr->normalFont, 0, 0,
+			    mPtr->view->size.width, WACenter, color, False, mPtr->text, strlen(mPtr->text));
+
+		WMReleaseColor(color);
+	}
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	_MyWidget *mPtr = (_MyWidget *) data;
+
+	switch (event->type) {
+	case Expose:
+		if (event->xexpose.count != 0)
+			break;
+		paintMyWidget(mPtr);
+		break;
+
+	case DestroyNotify:
+		destroyMyWidget(mPtr);
+		break;
+
+	}
+}
+
+static void handleActionEvents(XEvent * event, void *data)
+{
+	_MyWidget *mPtr = (_MyWidget *) data;
+
+	switch (event->type) {
+	case ButtonPress:
+		XBell(mPtr->view->screen->display, 100);
+		XBell(mPtr->view->screen->display, 100);
+		break;
+	}
+}
+
+void SetMyWidgetText(MyWidget * mPtr, char *text)
+{
+	CHECK_CLASS(mPtr, myWidgetClass);
+
+	if (mPtr->text)
+		wfree(mPtr->text);
+
+	mPtr->text = wstrdup(text);
+
+	if (W_VIEW_MAPPED(mPtr->view)) {
+		paintMyWidget(mPtr);
+	}
+}
+
+static void destroyMyWidget(_MyWidget * mPtr)
+{
+	/*
+	 * Free all data we allocated for our widget.
+	 */
+
+	if (mPtr->text)
+		wfree(mPtr->text);
+
+	wfree(mPtr);
+}

bazel/WINGs/Tests/mywidget.h

@@ -0,0 +1,15 @@
+
+/*
+ * Header for demo widget.
+ *
+ */
+
+typedef struct W_MyWidget MyWidget;
+
+
+MyWidget *CreateMyWidget(WMWidget *parent);
+
+void SetMyWidgetText(MyWidget *mPtr, char *text);
+
+W_Class InitMyWidget(WMScreen *scr);
+

bazel/WINGs/Tests/testmywidget.c

@@ -0,0 +1,46 @@
+
+#include <WINGs/WINGs.h>
+#include <stdlib.h>
+
+#include "mywidget.h"
+
+_Noreturn void wAbort(void)
+{
+	exit(1);
+}
+
+int main(int argc, char **argv)
+{
+	Display *dpy = XOpenDisplay("");
+	WMScreen *scr;
+	WMWindow *win;
+	MyWidget *thing;
+
+	WMInitializeApplication("Test", &argc, argv);
+
+	if (!dpy) {
+		wfatal("could not open display");
+		exit(1);
+	}
+
+	scr = WMCreateSimpleApplicationScreen(dpy);
+
+	/* init our widget */
+	InitMyWidget(scr);
+
+	win = WMCreateWindow(scr, "test");
+	WMResizeWidget(win, 150, 50);
+
+	thing = CreateMyWidget(win);
+	SetMyWidgetText(thing, "The Test");
+	WMResizeWidget(thing, 100, 20);
+	WMMoveWidget(thing, 10, 10);
+
+	WMRealizeWidget(win);
+	WMMapSubwidgets(win);
+	WMMapWidget(win);
+
+	WMScreenMainLoop(scr);
+
+	return 0;
+}

bazel/WINGs/Tests/upbtn.xpm

@@ -0,0 +1,57 @@
+/* XPM */
+static char * upbtn_xpm[] = {
+"20 22 32 1",
+" 	c None",
+".	c #000000",
+"+	c #FFFFFF",
+"@	c #4A485A",
+"#	c #524052",
+"$	c #4A595A",
+"%	c #5A596A",
+"&	c #4A486A",
+"*	c #5A595A",
+"=	c #52556A",
+"-	c #52406A",
+";	c #6A556A",
+">	c #5A6D6A",
+",	c #5A597B",
+"'	c #5A6D7B",
+")	c #6A557B",
+"!	c #6A6D7B",
+"~	c #6A697B",
+"{	c #6A698B",
+"]	c #7B797B",
+"^	c #C5C2C5",
+"/	c #6A818B",
+"(	c #6A7D7B",
+"_	c #7B698B",
+":	c #6A798B",
+"<	c #7B799C",
+"[	c #7B798B",
+"}	c #7B8D94",
+"|	c #7B81A4",
+"1	c #8B85A4",
+"2	c #73899C",
+"3	c #7B89A4",
+"                    ",
+"         .+         ",
+"        .@#+        ",
+"       .$%$&+       ",
+"      .*=*-*-+      ",
+"     .%%%%%%$%+     ",
+"    .%=%;%=*=*-+    ",
+"   .>%>,''>,>%=%+   ",
+"  .%)>)!~>)>)>=*#+  ",
+" .>~'~'{'{'~',>%$@+ ",
+" ]+++^{!{!~!)>+++++ ",
+"     ./{/{({'~+     ",
+"     ._:_:_!~>+     ",
+"     ./</</{'~+     ",
+"     .<<<[_({!+     ",
+"     .}|}</{(~+     ",
+"     .12<[_:{'+     ",
+"     .31}</{'~+     ",
+"     .12<[_!~>+     ",
+"     .2</</{''+     ",
+"     ]+++++++++     ",
+"                    "};

bazel/WINGs/Tests/wm.html

@@ -0,0 +1,37 @@
+<HTML><font size=-1>
+<center>
+<Img src=wm.png></b><p>
+<b>GNU Window Maker</B><br>
+<i>X11 Window Manager</i><p>
+<u>http://windowmaker.info<br>
+ftp.windowmaker.info</u></font><Br>
+</center>
+
+<b><i>Window Maker</b>
+<Img src=upbtn.xpm></i>is the GNU window manager
+for the X Window System. It was
+designed to emulate the look and feel of part of the NEXTSTEP(tm) GUI. Its
+supposed to be relatively fast and small, feature rich, easy to configure and
+easy to use, with a simple and elegant appearance borrowed from NEXTSTEP(tm).
+<p>
+<b>Window Maker</b> was designed keeping integration with GNUstep in
+mind and is the
+"official" window manager for it. It is also part of the GNU project
+(<u>www.gnu.org</u>)
+
+<p>
+<b>What is <i>GNUstep?</i></b><p>
+<i><b>G</i>NU</b>step is a complete object-oriented development system, based on the
+OpenStep specification released by NeXT(tm) (now Apple(tm)) and Sun(tm). It will provide everything one needs to produce cross-platform, object-oriented, graphical (and non-graphical) applications; providing among other things, base system libraries, a high-level GUI application framework that uses a Display PostScript(tm)-like imaging model (DGS), objects for accessing relational databases, distributed objects and a graphical development environment, with tools like interface modeller, a project management system
+(project center) and other tools.
+<p>
+The GNUstep development system will be used to create a user environment,
+with everything needed for a complete graphical user interface, such as a
+file viewer, text editors and other applications. Note that the user
+environment (or "desktop environment") is only a small part of the whole
+GNUstep project and therefore it does not "compete" with other projects like
+KDE or GNOME, simply because they are completely different things.
+<p>
+For more information on the GNUstep project, visit:
+<u>http://www.gnustep.org</u> and <u>http://gnustep.current.nu</u>
+</HTML>

bazel/WINGs/Tests/wmfile.c

@@ -0,0 +1,109 @@
+/*
+ * Author: Len Trigg <trigg@cs.waikato.ac.nz>
+ */
+
+/*
+ Update: Franck Wolff <frawolff@club-internet.fr>
+ -----------------------------------------------------------------------
+ List of updated functions :
+ - main :
+ add -s option for a save panel...
+ -----------------------------------------------------------------------
+ */
+
+#include <WINGs/WINGs.h>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "logo.xpm"
+
+_Noreturn void wAbort(void)
+{
+	exit(1);
+}
+
+char *ProgName;
+
+_Noreturn void usage(void)
+{
+	fprintf(stderr,
+		"usage:\n"
+		"\t%s [-options]\n"
+		"\n"
+		"options:\n"
+		"  -s\t\tSave panel (default open panel)\n"
+		"  -i <str>\tInitial directory (default /)\n"
+		"  -t <str>\tQuery window title (default none)\n"
+		"\n"
+		"information:\n"
+		"\t%s pops up a WindowMaker style file selection panel.\n"
+		"\n" "version:\n" "\t%s\n", ProgName, ProgName, __DATE__);
+	exit(0);
+}
+
+#define OPEN_PANEL_TYPE 0
+#define SAVE_PANEL_TYPE 1
+
+int main(int argc, char **argv)
+{
+	Display *dpy = XOpenDisplay("");
+	WMScreen *scr;
+	WMPixmap *pixmap;
+	WMOpenPanel *oPanel;
+	WMSavePanel *sPanel;
+	char *title = NULL;
+	char *initial = "/";
+	int ch;
+	int panelType = OPEN_PANEL_TYPE;
+
+	if (!dpy) {
+		puts("could not open display");
+		exit(1);
+	}
+
+	WMInitializeApplication("WMFile", &argc, argv);
+
+	ProgName = argv[0];
+
+	while ((ch = getopt(argc, argv, "si:ht:")) != -1)
+		switch (ch) {
+		case 's':
+			panelType = SAVE_PANEL_TYPE;
+			break;
+		case 'i':
+			initial = optarg;
+			break;
+		case 't':
+			title = optarg;
+			break;
+		default:
+			usage();
+		}
+
+	for (; optind < argc; optind++)
+		usage();
+
+	scr = WMCreateSimpleApplicationScreen(dpy);
+
+	pixmap = WMCreatePixmapFromXPMData(scr, GNUSTEP_XPM);
+	WMSetApplicationIconPixmap(scr, pixmap);
+	WMReleasePixmap(pixmap);
+	if (panelType == SAVE_PANEL_TYPE) {
+		sPanel = WMGetSavePanel(scr);
+		if (WMRunModalFilePanelForDirectory(sPanel, NULL, initial,
+						    title, NULL) == True)
+			printf("%s\n", WMGetFilePanelFileName(sPanel));
+		else
+			printf("\n");
+	} else {
+		oPanel = WMGetOpenPanel(scr);
+		if (WMRunModalFilePanelForDirectory(oPanel, NULL, initial,
+						   title, NULL) == True)
+			printf("%s\n", WMGetFilePanelFileName(oPanel));
+		else
+			printf("\n");
+	}
+	return 0;
+}

bazel/WINGs/Tests/wmquery.c

@@ -0,0 +1,88 @@
+
+/*
+ * Author: Len Trigg <trigg@cs.waikato.ac.nz>
+ */
+
+#include <WINGs/WINGs.h>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "logo.xpm"
+
+_Noreturn void wAbort(void)
+{
+	 exit(1);
+}
+
+char *ProgName;
+
+_Noreturn void usage(void)
+{
+	fprintf(stderr,
+		"usage:\n"
+		"\t%s [-options]\n"
+		"\n"
+		"options:\n"
+		"  -i <str>\tInitial entry contents (default none)\n"
+		"  -p <str>\tPrompt message (default none)\n"
+		"  -t <str>\tQuery window title (default none)\n"
+		"\n"
+		"information:\n"
+		"\t%s pops up a WindowMaker style input panel.\n"
+		"\n" "version:\n" "\t%s\n", ProgName, ProgName, __DATE__);
+	exit(0);
+}
+
+int main(int argc, char **argv)
+{
+	Display *dpy = XOpenDisplay("");
+	WMScreen *scr;
+	WMPixmap *pixmap;
+	char *title = NULL;
+	char *prompt = NULL;
+	char *initial = NULL;
+	char *result = NULL;
+	int ch;
+
+	WMInitializeApplication("WMQuery", &argc, argv);
+
+	ProgName = argv[0];
+
+	if (!dpy) {
+		puts("could not open display");
+		exit(1);
+	}
+
+	while ((ch = getopt(argc, argv, "i:hp:t:")) != -1)
+		switch (ch) {
+		case 'i':
+			initial = optarg;
+			break;
+		case 'p':
+			prompt = optarg;
+			break;
+		case 't':
+			title = optarg;
+			break;
+		default:
+			usage();
+		}
+
+	for (; optind < argc; optind++)
+		usage();
+
+	scr = WMCreateSimpleApplicationScreen(dpy);
+
+	pixmap = WMCreatePixmapFromXPMData(scr, GNUSTEP_XPM);
+
+	WMSetApplicationIconPixmap(scr, pixmap);
+	WMReleasePixmap(pixmap);
+
+	if ((result = WMRunInputPanel(scr, NULL, title, prompt, initial, "OK", "Cancel")) != NULL)
+		printf("%s\n", result);
+	else
+		printf("\n");
+	return 0;
+}

bazel/WINGs/WINGsP.h

@@ -0,0 +1,698 @@
+#ifndef _WINGSP_H_
+#define _WINGSP_H_
+
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+
+
+// TODO: Pango support was originally optional.
+#include "pango/pango.h"
+
+#include "WINGs/WINGs.h"
+
+#if WINGS_H_VERSION < 20041030
+#error There_is_an_old_WINGs.h_file_somewhere_in_your_system._Please_remove_it.
+#endif
+
+#include <assert.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* ---[ global settigns ]------------------------------------------------- */
+
+#define DOUBLE_BUFFER   1
+
+#define SCROLLER_WIDTH	20
+
+typedef struct _WINGsConfiguration {
+    char *systemFont;
+    char *boldSystemFont;
+    int  defaultFontSize;
+    Bool antialiasedText;
+    char *floppyPath;
+    unsigned doubleClickDelay;
+    unsigned mouseWheelUp;
+    unsigned mouseWheelDown;
+} _WINGsConfiguration;
+
+extern const char *_WINGS_progname;
+extern _WINGsConfiguration WINGsConfiguration;
+extern struct W_Application WMApplication;
+
+
+/* ---[ drag*.c ]--------------------------------------------------------- */
+
+/*
+ * We need to define these structure first because they are used in W_Screen
+ * below. The rest of drag-related stuff if after because it needs W_Screen
+ */
+#define XDND_VERSION    3
+
+typedef struct W_DraggingInfo {
+    unsigned char protocolVersion; /* version supported on the other side */
+    Time timestamp;
+
+    Atom sourceAction;
+    Atom destinationAction;
+
+    struct W_DragSourceInfo* sourceInfo;    /* infos needed by source */
+    struct W_DragDestinationInfo* destInfo; /* infos needed by destination */
+} W_DraggingInfo;
+
+/* ---[ Structures from WINGs.h ]----------------------------------------- */
+
+/* Pre-definition of internal structs */
+typedef struct W_Color W_Color;
+typedef struct W_Pixmap W_Pixmap;
+typedef struct W_View W_View;
+
+typedef struct W_FocusInfo {
+    W_View *toplevel;
+    W_View *focused;    /* view that has the focus in this toplevel */
+    struct W_FocusInfo *next;
+} W_FocusInfo;
+
+typedef struct W_Screen {
+    Display *display;
+    int screen;
+    int depth;
+
+    Colormap colormap;
+
+    Visual *visual;
+
+    Time lastEventTime;
+
+    Window rootWin;
+
+    W_View *rootView;
+
+    RContext *rcontext;
+
+    struct W_IMContext *imctx;
+
+    struct _XftDraw *xftdraw;          /* shared XftDraw */
+
+    /* application related */
+
+    W_FocusInfo *focusInfo;
+
+    RImage *applicationIconImage;      /* image (can have alpha channel) */
+    W_Pixmap *applicationIconPixmap; /* pixmap - no alpha channel */
+    Window applicationIconWindow;
+
+    struct W_Window *windowList;       /* list of windows in the app */
+
+    Window groupLeader;                /* the leader of the application */
+                                       /* also used for other things */
+
+    struct W_SelectionHandlers *selectionHandlerList;
+
+    struct {
+        unsigned int hasAppIcon:1;
+        unsigned int simpleApplication:1;
+    } aflags;
+
+    WMOpenPanel *sharedOpenPanel;
+    WMSavePanel *sharedSavePanel;
+
+    struct W_FontPanel *sharedFontPanel;
+
+    struct W_ColorPanel *sharedColorPanel;
+
+    Pixmap stipple;
+
+    W_View *dragSourceView;
+    W_DraggingInfo dragInfo;
+
+    /* colors */
+    W_Color *white;
+    W_Color *black;
+    W_Color *gray;
+    W_Color *darkGray;
+
+    GC stippleGC;
+
+    GC copyGC;
+    GC clipGC;
+
+    GC monoGC;                         /* GC for 1bpp visuals */
+
+    GC xorGC;
+
+    GC ixorGC;                         /* IncludeInferiors XOR */
+
+    GC drawStringGC;                   /* for WMDrawString() */
+
+    GC drawImStringGC;                 /* for WMDrawImageString() */
+
+    struct W_Font *normalFont;
+
+    struct W_Font *boldFont;
+
+    WMHashTable *fontCache;
+
+    Bool antialiasedText;
+
+    unsigned int ignoredModifierMask; /* modifiers to ignore when typing txt */
+
+    struct W_Balloon *balloon;
+
+
+    W_Pixmap *checkButtonImageOn;
+    W_Pixmap *checkButtonImageOff;
+
+    W_Pixmap *radioButtonImageOn;
+    W_Pixmap *radioButtonImageOff;
+
+    W_Pixmap *buttonArrow;
+    W_Pixmap *pushedButtonArrow;
+
+    W_Pixmap *scrollerDimple;
+
+    W_Pixmap *upArrow;
+    W_Pixmap *downArrow;
+    W_Pixmap *leftArrow;
+    W_Pixmap *rightArrow;
+
+    W_Pixmap *hiUpArrow;
+    W_Pixmap *hiDownArrow;
+    W_Pixmap *hiLeftArrow;
+    W_Pixmap *hiRightArrow;
+
+    W_Pixmap *pullDownIndicator;
+    W_Pixmap *popUpIndicator;
+
+    W_Pixmap *checkMark;
+
+    W_Pixmap *homeIcon;
+    W_Pixmap *altHomeIcon;
+
+    W_Pixmap *trashcanIcon;
+    W_Pixmap *altTrashcanIcon;
+
+    W_Pixmap *createDirIcon;
+    W_Pixmap *altCreateDirIcon;
+
+    W_Pixmap *disketteIcon;
+    W_Pixmap *altDisketteIcon;
+    W_Pixmap *unmountIcon;
+    W_Pixmap *altUnmountIcon;
+
+    W_Pixmap *magnifyIcon;
+    /*W_Pixmap *altMagnifyIcon;*/
+    W_Pixmap *wheelIcon;
+    W_Pixmap *grayIcon;
+    W_Pixmap *rgbIcon;
+    W_Pixmap *cmykIcon;
+    W_Pixmap *hsbIcon;
+    W_Pixmap *customPaletteIcon;
+    W_Pixmap *colorListIcon;
+
+    W_Pixmap *defaultObjectIcon;
+
+    Cursor defaultCursor;
+
+    Cursor textCursor;
+
+    Cursor invisibleCursor;
+
+    Atom attribsAtom;              /* GNUstepWindowAttributes */
+
+    Atom deleteWindowAtom;         /* WM_DELETE_WINDOW */
+
+    Atom protocolsAtom;            /* _XA_WM_PROTOCOLS */
+
+    Atom clipboardAtom;            /* CLIPBOARD */
+
+    Atom xdndAwareAtom;            /* XdndAware */
+    Atom xdndSelectionAtom;
+    Atom xdndEnterAtom;
+    Atom xdndLeaveAtom;
+    Atom xdndPositionAtom;
+    Atom xdndDropAtom;
+    Atom xdndFinishedAtom;
+    Atom xdndTypeListAtom;
+    Atom xdndActionListAtom;
+    Atom xdndActionDescriptionAtom;
+    Atom xdndStatusAtom;
+
+    Atom xdndActionCopy;
+    Atom xdndActionMove;
+    Atom xdndActionLink;
+    Atom xdndActionAsk;
+    Atom xdndActionPrivate;
+
+    Atom wmIconDragOffsetAtom;
+
+    Atom wmStateAtom;              /* WM_STATE */
+
+    Atom utf8String;
+
+    Atom netwmName;
+    Atom netwmIconName;
+    Atom netwmIcon;
+
+    /* stuff for detecting double-clicks */
+    Time lastClickTime;            /* time of last mousedown event */
+    Window lastClickWindow;        /* window of the last mousedown */
+
+    struct W_View *modalView;
+    unsigned modalLoop:1;
+    unsigned ignoreNextDoubleClick:1;
+
+    /*
+     * New stuff in Window Maker 0.95.7
+     * Added at the end of the structure to avoid breaking binary compatibility
+     * with previous versions of the toolkit
+     */
+    W_Pixmap *tristateButtonImageOn;
+    W_Pixmap *tristateButtonImageOff;
+    W_Pixmap *tristateButtonImageTri;
+
+} W_Screen;
+
+#define W_DRAWABLE(scr)		(scr)->rcontext->drawable
+
+
+/* ---[ configuration.c ]------------------------------------------------- */
+
+void W_ReadConfigurations(void);
+
+
+/* ---[ drag*.c ]--------------------------------------------------------- */
+
+typedef struct W_DragOperationItem {
+    WMDragOperationType type;
+    char* text;
+} W_DragOperationItem;
+
+typedef void* W_DndState(WMView *destView, XClientMessageEvent *event,
+                         WMDraggingInfo *info);
+
+typedef struct W_DragSourceInfo {
+    WMView *sourceView;
+    Window destinationWindow;
+    W_DndState *state;
+    WMSelectionProcs *selectionProcs;
+    Window icon;
+    WMPoint imageLocation;
+    WMPoint mouseOffset; /* mouse pos in icon */
+    Cursor dragCursor;
+    WMRect noPositionMessageZone;
+    Atom firstThreeTypes[3];
+} W_DragSourceInfo;
+
+typedef struct W_DragDestinationInfo {
+    WMView *destView;
+    WMView *xdndAwareView;
+    Window sourceWindow;
+    W_DndState *state;
+    Bool sourceActionChanged;
+    WMArray *sourceTypes;
+    WMArray *requiredTypes;
+    Bool typeListAvailable;
+    WMArray *dropDatas;
+} W_DragDestinationInfo;
+
+/* -- Functions -- */
+
+void W_HandleDNDClientMessage(WMView *toplevel, XClientMessageEvent *event);
+
+Atom W_OperationToAction(WMScreen *scr, WMDragOperationType operation);
+
+WMDragOperationType W_ActionToOperation(WMScreen *scr, Atom action);
+
+void W_FreeDragOperationItem(void* item);
+
+Bool W_SendDnDClientMessage(Display *dpy, Window win, Atom message,
+                            unsigned long data1, unsigned long data2,
+                            unsigned long data3, unsigned long data4,
+                            unsigned long data5);
+
+void W_DragSourceStartTimer(WMDraggingInfo *info);
+
+void W_DragSourceStopTimer(void);
+
+void W_DragSourceStateHandler(WMDraggingInfo *info, XClientMessageEvent *event);
+
+void W_DragDestinationStartTimer(WMDraggingInfo *info);
+
+void W_DragDestinationStopTimer(void);
+
+void W_DragDestinationStoreEnterMsgInfo(WMDraggingInfo *info, WMView *toplevel,
+                                        XClientMessageEvent *event);
+
+void W_DragDestinationStorePositionMsgInfo(WMDraggingInfo *info,
+                                           WMView *toplevel,
+                                           XClientMessageEvent *event);
+
+void W_DragDestinationCancelDropOnEnter(WMView *toplevel, WMDraggingInfo *info);
+
+void W_DragDestinationStateHandler(WMDraggingInfo *info,
+                                   XClientMessageEvent *event);
+
+void W_DragDestinationInfoClear(WMDraggingInfo *info);
+
+void W_FreeViewXdndPart(WMView *view);
+
+
+/* ---[ handlers.c ]------------------------------------------------------ */
+
+Bool W_CheckIdleHandlers(void);
+
+void W_CheckTimerHandlers(void);
+
+Bool W_HandleInputEvents(Bool waitForInput, int inputfd);
+
+
+/* ---[ notification.c ]-------------------------------------------------- */
+
+void W_InitNotificationCenter(void);
+
+void W_ReleaseNotificationCenter(void);
+
+void W_FlushASAPNotificationQueue(void);
+
+void W_FlushIdleNotificationQueue(void);
+
+
+/* ---[ selection.c ]----------------------------------------------------- */
+
+void W_HandleSelectionEvent(XEvent *event);
+
+
+/* ---[ wapplication.c ]-------------------------------------------------- */
+
+typedef struct W_Application {
+    char *applicationName;
+    int argc;
+    char **argv;
+    char *resourcePath;
+} W_Application;
+
+/* -- Functions -- */
+
+void W_InitApplication(WMScreen *scr);
+
+Bool W_ApplicationInitialized(void);
+
+
+/* ---[ wballoon.c ]------------------------------------------------------ */
+
+struct W_Balloon *W_CreateBalloon(WMScreen *scr);
+
+void W_BalloonHandleEnterView(WMView *view);
+
+void W_BalloonHandleLeaveView(WMView *view);
+
+
+/* ---[ wcolor.c ]-------------------------------------------------------- */
+
+struct W_Color {
+    struct W_Screen *screen;
+
+    XColor color;
+    unsigned short alpha;
+    short refCount;
+    GC gc;
+    struct {
+        unsigned int exact:1;
+    } flags;
+};
+
+#define W_PIXEL(c)		(c)->color.pixel
+
+
+/* ---[ wevent.c ]-------------------------------------------------------- */
+
+typedef struct W_EventHandler {
+    unsigned long eventMask;
+
+    WMEventProc *proc;
+
+    void *clientData;
+} W_EventHandler;
+
+/* -- Functions -- */
+
+void W_CallDestroyHandlers(W_View *view);
+
+
+/* ---[ wfont.c ]--------------------------------------------------------- */
+
+typedef struct W_Font {
+    struct W_Screen *screen;
+
+    struct _XftFont *font;
+
+    short height;
+    short y;
+    short refCount;
+    char *name;
+
+// TODO: Pango support was originally optional.
+    PangoLayout *layout;
+} W_Font;
+
+#define W_FONTID(f)		(f)->font->fid
+
+
+/* ---[ widgets.c ]------------------------------------------------------- */
+
+#define WC_UserWidget	128
+
+#define CHECK_CLASS(widget, class) assert(W_CLASS(widget)==(class))
+
+#define W_CLASS(widget)  	(((W_WidgetType*)(widget))->widgetClass)
+#define W_VIEW(widget)   	(((W_WidgetType*)(widget))->view)
+
+/* -- Functions -- */
+
+W_Class W_RegisterUserWidget(void);
+
+
+/* ---[ winputmethod.c ]-------------------------------------------------- */
+
+void W_InitIM(WMScreen *scr);
+
+void W_CreateIC(WMView *view);
+
+void W_DestroyIC(WMView *view);
+
+void W_FocusIC(WMView *view);
+
+void W_UnFocusIC(WMView *view);
+
+void W_SetPreeditPositon(W_View *view, int x, int y);
+
+int W_LookupString(W_View *view, XKeyPressedEvent *event, char *buffer,
+                   int buflen, KeySym *keysym, Status *status);
+
+KeySym W_KeycodeToKeysym(Display *display, KeyCode keycode, int index);
+
+
+/* ---[ wmisc.c ]--------------------------------------------------------- */
+
+void W_DrawRelief(W_Screen *scr, Drawable d, int x, int y, unsigned int width,
+                  unsigned int height, WMReliefType relief);
+
+void W_DrawReliefWithGC(W_Screen *scr, Drawable d, int x, int y,
+                        unsigned int width, unsigned int height,
+                        WMReliefType relief,
+                        GC black, GC dark, GC light, GC white);
+
+void W_PaintTextAndImage(W_View *view, int wrap, WMColor *textColor,
+                         W_Font *font, WMReliefType relief, const char *text,
+                         WMAlignment alignment, W_Pixmap *image,
+                         WMImagePosition position, WMColor *backColor, int ofs);
+
+void W_PaintText(W_View *view, Drawable d, WMFont *font,  int x, int y,
+                 int width, WMAlignment alignment, WMColor *color,
+                 int wrap, const char *text, int length);
+
+int W_GetTextHeight(WMFont *font, const char *text, int width, int wrap);
+
+
+/* ---[ wpixmap.c ]------------------------------------------------------- */
+
+struct W_Pixmap {
+    struct W_Screen *screen;
+    Pixmap pixmap;
+    Pixmap mask;
+    unsigned short width;
+    unsigned short height;
+    short depth;
+    short refCount;
+};
+
+
+/* ---[ wview.c ]--------------------------------------------------------- */
+
+typedef struct W_ViewDelegate {
+    void *data;
+    void (*didMove)(struct W_ViewDelegate*, WMView*);
+    void (*didResize)(struct W_ViewDelegate*, WMView*);
+    void (*willMove)(struct W_ViewDelegate*, WMView*, int*, int*);
+    void (*willResize)(struct W_ViewDelegate*, WMView*,
+                       unsigned int*, unsigned int*);
+} W_ViewDelegate;
+
+struct W_View {
+    struct W_Screen *screen;
+
+    WMWidget *self;     /* must point to the widget the view belongs to */
+
+    W_ViewDelegate *delegate;
+
+    Window window;
+
+    WMSize size;
+
+    short topOffs;
+    short leftOffs;
+    short bottomOffs;
+    short rightOffs;
+
+    WMPoint pos;
+
+    struct W_View *nextFocusChain;     /* next/prev in focus chain */
+    struct W_View *prevFocusChain;
+
+    struct W_View *nextResponder;      /* next to receive keyboard events */
+
+    struct W_View *parent;             /* parent WMView */
+
+    struct W_View *childrenList;       /* first in list of child windows */
+
+    struct W_View *nextSister;         /* next on parent's children list */
+
+    WMArray *eventHandlers;            /* event handlers for this window */
+
+    unsigned long attribFlags;
+    XSetWindowAttributes attribs;
+
+    void *hangedData;                  /* data holder for user program */
+
+    WMColor *backColor;
+    WMPixmap *backImage;
+
+
+    Cursor cursor;
+
+    Atom *droppableTypes;
+    struct W_DragSourceProcs      *dragSourceProcs;
+    struct W_DragDestinationProcs *dragDestinationProcs;
+    WMPixmap *dragImage;
+    int helpContext;
+
+    XIC xic;
+
+    struct {
+        unsigned int realized:1;
+        unsigned int mapped:1;
+        unsigned int parentDying:1;
+        unsigned int dying:1;           /* the view is being destroyed */
+        unsigned int topLevel:1;        /* is a top level window */
+        unsigned int root:1;            /* is the root window */
+        unsigned int mapWhenRealized:1; /* map the view when it's realized */
+        unsigned int alreadyDead:1;     /* view was freed */
+
+        unsigned int dontCompressMotion:1; /* motion notify event compress */
+        unsigned int notifySizeChanged:1;
+        unsigned int dontCompressExpose:1; /* expose event compress */
+
+        /* toplevel only */
+        unsigned int worksWhenModal:1;
+        unsigned int pendingRelease1:1;
+        unsigned int pendingRelease2:1;
+        unsigned int pendingRelease3:1;
+        unsigned int pendingRelease4:1;
+        unsigned int pendingRelease5:1;
+        unsigned int xdndHintSet:1;
+    } flags;
+
+    int refCount;
+};
+
+#define W_VIEW_REALIZED(view)	(view)->flags.realized
+#define W_VIEW_MAPPED(view)	(view)->flags.mapped
+
+#define W_VIEW_DISPLAY(view)    (view)->screen->display
+#define W_VIEW_SCREEN(view)	(view)->screen
+#define W_VIEW_DRAWABLE(view)	(view)->window
+
+#define W_VIEW_WIDTH(view)	(view)->size.width
+#define W_VIEW_HEIGHT(view)	(view)->size.height
+
+/* -- Functions -- */
+
+W_View *W_GetViewForXWindow(Display *display, Window window);
+
+W_View *W_CreateView(W_View *parent);
+
+W_View *W_CreateTopView(W_Screen *screen);
+
+W_View *W_CreateUnmanagedTopView(W_Screen *screen);
+
+W_View *W_CreateRootView(W_Screen *screen);
+
+void W_DestroyView(W_View *view);
+
+void W_RealizeView(W_View *view);
+
+void W_RedisplayView(WMView *view);
+
+void W_ReparentView(W_View *view, W_View *newParent, int x, int y);
+
+void W_RaiseView(W_View *view);
+
+void W_LowerView(W_View *view);
+
+void W_MapView(W_View *view);
+
+void W_MapSubviews(W_View *view);
+
+void W_UnmapSubviews(W_View *view);
+
+W_View *W_TopLevelOfView(W_View *view);
+
+void W_UnmapView(W_View *view);
+
+WMView *W_RetainView(WMView *view);
+
+void W_ReleaseView(WMView *view);
+
+void W_MoveView(W_View *view, int x, int y);
+
+void W_ResizeView(W_View *view, unsigned int width, unsigned int height);
+
+void W_SetViewBackgroundColor(W_View *view, WMColor *color);
+
+void W_SetViewBackgroundPixmap(W_View *view, WMPixmap *pix);
+
+void W_SetViewCursor(W_View *view, Cursor cursor);
+
+void W_SetFocusOfTopLevel(W_View *toplevel, W_View *view);
+
+W_View *W_FocusedViewOfToplevel(W_View *view);
+
+void W_BroadcastMessage(W_View *targetParent, XEvent *event);
+
+void W_DispatchMessage(W_View *target, XEvent *event);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _WINGSP_H_ */

bazel/WINGs/WUtil.h

@@ -0,0 +1,959 @@
+/* WUtil.h
+ *
+ *  Copyright (c) 1998 scottc
+ *  Copyright (c) 1999-2004 Dan Pascu
+ *  Copyright (c) 1999-2000 Alfredo K. Kojima
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef _WUTIL_H_
+#define _WUTIL_H_
+
+#include <X11/Xlib.h>
+#include <limits.h>
+#include <sys/types.h>
+
+/* SunOS 4.x Blargh.... */
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+
+#ifndef WMAX
+# define WMAX(a,b)	((a)>(b) ? (a) : (b))
+#endif
+#ifndef WMIN
+# define WMIN(a,b)	((a)<(b) ? (a) : (b))
+#endif
+
+
+#ifndef __GNUC__
+#define  __attribute__(x)  /*NOTHING*/
+#endif
+
+#ifdef NDEBUG
+
+#define wassertr(expr)  \
+	if (!(expr)) { return; }
+
+#define wassertrv(expr, val)  \
+	if (!(expr)) { return (val); }
+
+#else /* !NDEBUG */
+
+#define wassertr(expr) \
+    if (!(expr)) { \
+        wwarning("wassertr: assertion %s failed", #expr); \
+        return;\
+    }
+
+#define wassertrv(expr, val) \
+    if (!(expr)) { \
+        wwarning("wassertrv: assertion %s failed", #expr); \
+        return (val);\
+    }
+
+#endif /* !NDEBUG */
+
+
+#ifdef static_assert
+# define _wutil_static_assert(check, message) static_assert(check, message)
+#else
+# ifdef __STDC_VERSION__
+#  if __STDC_VERSION__ >= 201112L
+/*
+ * Ideally, we would like to include <assert.h> to have 'static_assert'
+ * properly defined, but as we have to be sure about portability and
+ * because we're a public header we can't count on 'configure' to tell
+ * us about availability, so we use the raw C11 keyword
+ */
+#   define _wutil_static_assert(check, message) _Static_assert(check, message)
+#  else
+#   define _wutil_static_assert(check, message) /**/
+#  endif
+# else
+#  define _wutil_static_assert(check, message) /**/
+# endif
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+typedef enum {
+    WMPostWhenIdle = 1,
+    WMPostASAP = 2,
+    WMPostNow = 3
+} WMPostingStyle;
+
+
+typedef enum {
+    WNCNone = 0,
+    WNCOnName = 1,
+    WNCOnSender = 2
+} WMNotificationCoalescing;
+
+
+
+enum {
+    WBNotFound = INT_MIN, /* element was not found in WMBag   */
+    WANotFound = -1       /* element was not found in WMArray */
+};
+
+
+typedef struct W_Array WMArray;
+typedef struct W_Bag WMBag;
+typedef struct W_Data WMData;
+typedef struct W_TreeNode WMTreeNode;
+typedef struct W_HashTable WMHashTable;
+typedef struct W_UserDefaults WMUserDefaults;
+typedef struct W_Notification WMNotification;
+typedef struct W_NotificationQueue WMNotificationQueue;
+typedef struct W_Host WMHost;
+typedef struct W_Connection WMConnection;
+typedef struct W_PropList WMPropList;
+
+
+
+/* Some typedefs for the handler stuff */
+typedef void *WMHandlerID;
+
+typedef void WMCallback(void *data);
+
+typedef void WMInputProc(int fd, int mask, void *clientData);
+
+
+
+typedef int WMCompareDataProc(const void *item1, const void *item2);
+typedef void WMTreeWalkProc(WMTreeNode *aNode, void *data);
+
+typedef void WMFreeDataProc(void *data);
+
+/* Used by WMBag or WMArray for matching data */
+typedef int WMMatchDataProc(const void *item, const void *cdata);
+
+
+
+typedef struct {
+    int position;
+    int count;
+} WMRange;
+
+
+
+/* DO NOT ACCESS THE CONTENTS OF THIS STRUCT */
+typedef struct {
+    void *table;
+    void *nextItem;
+    int index;
+} WMHashEnumerator;
+
+
+typedef struct {
+    /* NULL is pointer hash */
+    unsigned 	(*hash)(const void *);
+    /* NULL is pointer compare */
+    Bool	(*keyIsEqual)(const void *, const void *);
+    /* NULL does nothing */
+    void*	(*retainKey)(const void *);
+    /* NULL does nothing */
+    void	(*releaseKey)(const void *);
+} WMHashTableCallbacks;
+
+
+typedef int WMArrayIterator;
+typedef void *WMBagIterator;
+
+
+typedef void WMNotificationObserverAction(void *observerData,
+                                          WMNotification *notification);
+
+
+/* ---[ Macros ]---------------------------------------------------------- */
+
+#define wlengthof(array)  \
+	({   \
+		_wutil_static_assert(sizeof(array) > sizeof(array[0]),   \
+		                     "the macro 'wlengthof' cannot be used on pointers, only on known size arrays");   \
+		sizeof(array) / sizeof(array[0]);   \
+	})
+
+/* These macros can be used to adjust the location and size pixel values in
+ * the panel layouts so that they match the configured size of the system
+ * font (useful with high DPI screens, where you have to increase this size).
+ * The macros require two local variables to be set:
+ *    wmScaleWidth:  the width of the alphabet in the current system font
+ *    wmScaleHeight: the height of the current system font
+ * Use the WMGetScaleBaseFromSystemFont function to set these values.
+ */
+#define WMScaleX(value) ((int)((double)value / 177.0 * (double)wmScaleWidth + 0.5))
+#define WMScaleY(value) ((int)((double)value / 15.0 * (double)wmScaleHeight + 0.5))
+
+/* ---[ WINGs/memory.c ]-------------------------------------------------- */
+
+void* wmalloc(size_t size);
+void* wrealloc(void *ptr, size_t newsize);
+void wfree(void *ptr);
+
+void wrelease(void *ptr);
+void* wretain(void *ptr);
+
+typedef void waborthandler(int);
+
+waborthandler* wsetabort(waborthandler* handler);
+
+/* ---[ WINGs/error.c ]--------------------------------------------------- */
+
+enum {
+	WMESSAGE_TYPE_MESSAGE,
+	WMESSAGE_TYPE_WARNING,
+	WMESSAGE_TYPE_ERROR,
+	WMESSAGE_TYPE_FATAL
+};
+
+#define wmessage(fmt, args...) __wmessage( __func__, __FILE__, __LINE__, WMESSAGE_TYPE_MESSAGE, fmt, ## args)
+#define wwarning(fmt, args...) __wmessage( __func__, __FILE__, __LINE__, WMESSAGE_TYPE_WARNING, fmt, ## args)
+#define werror(fmt, args...) __wmessage( __func__, __FILE__, __LINE__, WMESSAGE_TYPE_ERROR, fmt, ## args)
+#define wfatal(fmt, args...) __wmessage( __func__, __FILE__, __LINE__, WMESSAGE_TYPE_FATAL, fmt, ## args)
+
+void __wmessage(const char *func, const char *file, int line, int type, const char *msg, ...)
+	__attribute__((__format__(printf,5,6)));
+
+/* ---[ WINGs/findfile.c ]------------------------------------------------ */
+
+/* For the 4 function below, you have to free the returned string when you no longer need it */
+
+char* wfindfile(const char *paths, const char *file);
+
+char* wfindfileinlist(char *const *path_list, const char *file);
+
+char* wfindfileinarray(WMPropList* array, const char *file);
+
+char* wexpandpath(const char *path);
+
+int wcopy_file(const char *toPath, const char *srcFile, const char *destFile);
+
+/* don't free the returned string */
+const char* wgethomedir(void);
+
+/* ---[ WINGs/proplist.c ]------------------------------------------------ */
+
+int wmkdirhier(const char *path);
+int wrmdirhier(const char *path);
+
+/* ---[ WINGs/string.c ]-------------------------------------------------- */
+
+char *wstrdup(const char *str);
+char* wstrndup(const char *str, size_t len);
+
+/* Concatenate str1 with str2 and return that in a newly malloc'ed string.
+ * str1 and str2 can be any strings including static and constant strings.
+ * str1 and str2 will not be modified.
+ * Free the returned string when you're done with it. */
+char* wstrconcat(const char *str1, const char *str2);
+
+/* This will append src to dst, and return dst. dst MUST be either NULL
+ * or a string that was a result of a dynamic allocation (malloc, realloc
+ * wmalloc, wrealloc, ...). dst CANNOT be a static or a constant string!
+ * Modifies dst (no new string is created except if dst==NULL in which case
+ * it is equivalent to calling wstrdup(src) ).
+ * The returned address may be different from the original address of dst,
+ * so always assign the returned address to avoid dangling pointers. */
+char* wstrappend(char *dst, const char *src);
+
+size_t wstrlcpy(char *, const char *, size_t);
+size_t wstrlcat(char *, const char *, size_t);
+
+
+void wtokensplit(char *command, char ***argv, int *argc);
+
+char* wtokennext(char *word, char **next);
+
+char* wtokenjoin(char **list, int count);
+
+void wtokenfree(char **tokens, int count);
+
+char* wtrimspace(const char *s);
+
+/* transform `s' so that the result is safe to pass to the shell as an argument.
+ * returns a newly allocated string.
+ * with very heavy inspirations from NetBSD's shquote(3).
+ */
+char *wshellquote(const char *s);
+
+/* ---[ WINGs/misc.c ]--------------------------------------------------- */
+
+WMRange wmkrange(int start, int count);
+
+/* An application must call this function before exiting, to let WUtil do some internal cleanup */
+void wutil_shutdown(void);
+
+
+/* ---[ WINGs/usleep.c ]-------------------------------------------------- */
+
+void wusleep(unsigned int usec);
+
+/* ---[ WINGs/handlers.c ]------------------------------------------------ */
+
+/* Event handlers: timer, idle, input */
+
+WMHandlerID WMAddTimerHandler(int milliseconds, WMCallback *callback,
+                              void *cdata);
+
+WMHandlerID WMAddPersistentTimerHandler(int milliseconds, WMCallback *callback,
+                                        void *cdata);
+
+void WMDeleteTimerWithClientData(void *cdata);
+
+void WMDeleteTimerHandler(WMHandlerID handlerID);
+
+WMHandlerID WMAddIdleHandler(WMCallback *callback, void *cdata);
+
+void WMDeleteIdleHandler(WMHandlerID handlerID);
+
+WMHandlerID WMAddInputHandler(int fd, int condition, WMInputProc *proc,
+                              void *clientData);
+
+void WMDeleteInputHandler(WMHandlerID handlerID);
+
+
+/* This function is used _only_ if you create a non-GUI program.
+ * For GUI based programs use WMNextEvent()/WMHandleEvent() instead.
+ * This function will handle all input/timer/idle events, then return.
+ */
+
+void WHandleEvents(void);
+
+/* ---[ WINGs/hashtable.c ]----------------------------------------------- */
+
+
+WMHashTable* WMCreateHashTable(const WMHashTableCallbacks callbacks);
+
+void WMFreeHashTable(WMHashTable *table);
+
+void WMResetHashTable(WMHashTable *table);
+
+unsigned WMCountHashTable(WMHashTable *table);
+
+void* WMHashGet(WMHashTable *table, const void *key);
+
+/* Returns True if there is a value associated with <key> in the table, in
+ * which case <retKey> and <retItem> will contain the item's internal key
+ * address and the item's value respectively.
+ * If there is no value associated with <key> it will return False and in
+ * this case <retKey> and <retItem> will be undefined.
+ * Use this when you need to perform your own custom retain/release mechanism
+ * which requires access to the keys too.
+ */
+Bool WMHashGetItemAndKey(WMHashTable *table, const void *key,
+                         void **retItem, void **retKey);
+
+/* put data in table, replacing already existing data and returning
+ * the old value */
+void* WMHashInsert(WMHashTable *table, const void *key, const void *data);
+
+void WMHashRemove(WMHashTable *table, const void *key);
+
+/* warning: do not manipulate the table while using the enumerator functions */
+WMHashEnumerator WMEnumerateHashTable(WMHashTable *table);
+
+void* WMNextHashEnumeratorItem(WMHashEnumerator *enumerator);
+
+void* WMNextHashEnumeratorKey(WMHashEnumerator *enumerator);
+
+/* Returns True if there is a next element, in which case key and item
+ * will contain the next element's key and value respectively.
+ * If there is no next element available it will return False and in this
+ * case key and item will be undefined.
+ */
+Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator *enumerator,
+                                    void **item, void **key);
+
+
+
+
+/* some predefined callback sets */
+
+extern const WMHashTableCallbacks WMIntHashCallbacks;
+/* sizeof(keys) are <= sizeof(void*) */
+
+extern const WMHashTableCallbacks WMStringHashCallbacks;
+/* keys are strings. Strings will be copied with wstrdup()
+ * and freed with wfree() */
+
+extern const WMHashTableCallbacks WMStringPointerHashCallbacks;
+/* keys are strings, but they are not copied */
+
+
+/* ---[ WINGs/array.c ]--------------------------------------------------- */
+
+/*
+ * WMArray use an array to store the elements.
+ * Item indexes may be only positive integer numbers.
+ * The array cannot contain holes in it.
+ *
+ * Pros:
+ * Fast [O(1)] access to elements
+ * Fast [O(1)] push/pop
+ *
+ * Cons:
+ * A little slower [O(n)] for insertion/deletion of elements that
+ * 	aren't in the end
+ */
+
+WMArray* WMCreateArray(int initialSize);
+
+WMArray* WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor);
+
+WMArray* WMCreateArrayWithArray(WMArray *array);
+
+#define WMDuplicateArray(array) WMCreateArrayWithArray(array)
+
+void WMEmptyArray(WMArray *array);
+
+void WMFreeArray(WMArray *array);
+
+int WMGetArrayItemCount(WMArray *array);
+
+/* appends other to array. other remains unchanged */
+void WMAppendArray(WMArray *array, WMArray *other);
+
+/* add will place the element at the end of the array */
+void WMAddToArray(WMArray *array, void *item);
+
+/* insert will increment the index of elements after it by 1 */
+void WMInsertInArray(WMArray *array, int index, void *item);
+
+/* replace and set will return the old item WITHOUT calling the
+ * destructor on it even if its available. Free the returned item yourself.
+ */
+void* WMReplaceInArray(WMArray *array, int index, void *item);
+
+#define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item)
+
+/* delete and remove will remove the elements and cause the elements
+ * after them to decrement their indexes by 1. Also will call the
+ * destructor on the deleted element if there's one available.
+ */
+int WMDeleteFromArray(WMArray *array, int index);
+
+#define WMRemoveFromArray(array, item) WMRemoveFromArrayMatching(array, NULL, item)
+
+int WMRemoveFromArrayMatching(WMArray *array, WMMatchDataProc *match, void *cdata);
+
+void* WMGetFromArray(WMArray *array, int index);
+
+#define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item)
+
+/* pop will return the last element from the array, also removing it
+ * from the array. The destructor is NOT called, even if available.
+ * Free the returned element if needed by yourself
+ */
+void* WMPopFromArray(WMArray *array);
+
+int WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata);
+
+int WMCountInArray(WMArray *array, void *item);
+
+/* comparer must return:
+ * < 0 if a < b
+ * > 0 if a > b
+ * = 0 if a = b
+ */
+void WMSortArray(WMArray *array, WMCompareDataProc *comparer);
+
+void WMMapArray(WMArray *array, void (*function)(void*, void*), void *data);
+
+WMArray* WMGetSubarrayWithRange(WMArray* array, WMRange aRange);
+
+void* WMArrayFirst(WMArray *array, WMArrayIterator *iter);
+
+void* WMArrayLast(WMArray *array, WMArrayIterator *iter);
+
+/* The following 2 functions assume that the array doesn't change between calls */
+void* WMArrayNext(WMArray *array, WMArrayIterator *iter);
+
+void* WMArrayPrevious(WMArray *array, WMArrayIterator *iter);
+
+
+/* The following 2 macros assume that the array doesn't change in the for loop */
+#define WM_ITERATE_ARRAY(array, var, i) \
+    for (var = WMArrayFirst(array, &(i)); (i) != WANotFound; \
+    var = WMArrayNext(array, &(i)))
+
+#define WM_ETARETI_ARRAY(array, var, i) \
+    for (var = WMArrayLast(array, &(i)); (i) != WANotFound; \
+    var = WMArrayPrevious(array, &(i)))
+
+/* ---[ WINGs/bagtree.c ]------------------------------------------------- */
+
+/*
+ * Tree bags use a red-black tree for storage.
+ * Item indexes may be any integer number.
+ *
+ * Pros:
+ * O(lg n) insertion/deletion/search
+ * Good for large numbers of elements with sparse indexes
+ *
+ * Cons:
+ * O(lg n) insertion/deletion/search
+ * Slow for storing small numbers of elements
+ */
+
+#define WMCreateBag(size) WMCreateTreeBag()
+
+#define WMCreateBagWithDestructor(size, d) WMCreateTreeBagWithDestructor(d)
+
+WMBag* WMCreateTreeBag(void);
+
+WMBag* WMCreateTreeBagWithDestructor(WMFreeDataProc *destructor);
+
+int WMGetBagItemCount(WMBag *bag);
+
+void WMAppendBag(WMBag *bag, WMBag *other);
+
+void WMPutInBag(WMBag *bag, void *item);
+
+/* insert will increment the index of elements after it by 1 */
+void WMInsertInBag(WMBag *bag, int index, void *item);
+
+/* erase will remove the element from the bag,
+ * but will keep the index of the other elements unchanged */
+int WMEraseFromBag(WMBag *bag, int index);
+
+/* delete and remove will remove the elements and cause the elements
+ * after them to decrement their indexes by 1 */
+int WMDeleteFromBag(WMBag *bag, int index);
+
+int WMRemoveFromBag(WMBag *bag, void *item);
+
+void* WMGetFromBag(WMBag *bag, int index);
+
+void* WMReplaceInBag(WMBag *bag, int index, void *item);
+
+#define WMSetInBag(bag, index, item) WMReplaceInBag(bag, index, item)
+
+/* comparer must return:
+ * < 0 if a < b
+ * > 0 if a > b
+ * = 0 if a = b
+ */
+void WMSortBag(WMBag *bag, WMCompareDataProc *comparer);
+
+void WMEmptyBag(WMBag *bag);
+
+void WMFreeBag(WMBag *bag);
+
+void WMMapBag(WMBag *bag, void (*function)(void*, void*), void *data);
+
+int WMGetFirstInBag(WMBag *bag, void *item);
+
+int WMCountInBag(WMBag *bag, void *item);
+
+int WMFindInBag(WMBag *bag, WMMatchDataProc *match, void *cdata);
+
+void* WMBagFirst(WMBag *bag, WMBagIterator *ptr);
+
+void* WMBagLast(WMBag *bag, WMBagIterator *ptr);
+
+/* The following 4 functions assume that the bag doesn't change between calls */
+void* WMBagNext(WMBag *bag, WMBagIterator *ptr);
+
+void* WMBagPrevious(WMBag *bag, WMBagIterator *ptr);
+
+void* WMBagIteratorAtIndex(WMBag *bag, int index, WMBagIterator *ptr);
+
+int WMBagIndexForIterator(WMBag *bag, WMBagIterator ptr);
+
+
+/* The following 2 macros assume that the bag doesn't change in the for loop */
+#define WM_ITERATE_BAG(bag, var, i) \
+    for (var = WMBagFirst(bag, &(i)); (i) != NULL; \
+    var = WMBagNext(bag, &(i)))
+
+#define WM_ETARETI_BAG(bag, var, i) \
+    for (var = WMBagLast(bag, &(i)); (i) != NULL; \
+    var = WMBagPrevious(bag, &(i)))
+
+
+
+/* ---[ WINGs/data.c ]---------------------------------------------------- */
+
+/* WMData handling */
+
+/* Creating/destroying data */
+
+WMData* WMCreateDataWithCapacity(unsigned capacity);
+
+WMData* WMCreateDataWithLength(unsigned length);
+
+WMData* WMCreateDataWithBytes(const void *bytes, unsigned length);
+
+/* destructor is a function called to free the data when releasing the data
+ * object, or NULL if no freeing of data is necesary. */
+WMData* WMCreateDataWithBytesNoCopy(void *bytes, unsigned length,
+                                    WMFreeDataProc *destructor);
+
+WMData* WMCreateDataWithData(WMData *aData);
+
+WMData* WMRetainData(WMData *aData);
+
+void WMReleaseData(WMData *aData);
+
+/* Adjusting capacity */
+
+void WMSetDataCapacity(WMData *aData, unsigned capacity);
+
+void WMSetDataLength(WMData *aData, unsigned length);
+
+void WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength);
+
+/* Accessing data */
+
+const void* WMDataBytes(WMData *aData);
+
+void WMGetDataBytes(WMData *aData, void *buffer);
+
+void WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length);
+
+void WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange);
+
+WMData* WMGetSubdataWithRange(WMData *aData, WMRange aRange);
+
+/* Testing data */
+
+Bool WMIsDataEqualToData(WMData *aData, WMData *anotherData);
+
+unsigned WMGetDataLength(WMData *aData);
+
+/* Adding data */
+
+void WMAppendDataBytes(WMData *aData, const void *bytes, unsigned length);
+
+void WMAppendData(WMData *aData, WMData *anotherData);
+
+/* Modifying data */
+
+void WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, const void *bytes);
+
+void WMResetDataBytesInRange(WMData *aData, WMRange aRange);
+
+void WMSetData(WMData *aData, WMData *anotherData);
+
+
+void WMSetDataFormat(WMData *aData, unsigned format);
+
+unsigned WMGetDataFormat(WMData *aData);
+/* Storing data */
+
+/* ---[ WINGs/tree.c ]---------------------------------------------------- */
+
+/* Generic Tree and TreeNode */
+
+WMTreeNode* WMCreateTreeNode(void *data);
+
+WMTreeNode* WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc *destructor);
+
+WMTreeNode* WMInsertItemInTree(WMTreeNode *parent, int index, void *item);
+
+#define WMAddItemToTree(parent, item)  WMInsertItemInTree(parent, -1, item)
+
+WMTreeNode* WMInsertNodeInTree(WMTreeNode *parent, int index, WMTreeNode *aNode);
+
+#define WMAddNodeToTree(parent, aNode)  WMInsertNodeInTree(parent, -1, aNode)
+
+void WMDestroyTreeNode(WMTreeNode *aNode);
+
+void WMDeleteLeafForTreeNode(WMTreeNode *aNode, int index);
+
+void WMRemoveLeafForTreeNode(WMTreeNode *aNode, void *leaf);
+
+void* WMReplaceDataForTreeNode(WMTreeNode *aNode, void *newData);
+
+void* WMGetDataForTreeNode(WMTreeNode *aNode);
+
+int WMGetTreeNodeDepth(WMTreeNode *aNode);
+
+WMTreeNode* WMGetParentForTreeNode(WMTreeNode *aNode);
+
+/* Sort only the leaves of the passed node */
+void WMSortLeavesForTreeNode(WMTreeNode *aNode, WMCompareDataProc *comparer);
+
+/* Sort all tree recursively starting from the passed node */
+void WMSortTree(WMTreeNode *aNode, WMCompareDataProc *comparer);
+
+/* Returns the first node which matches node's data with cdata by 'match' */
+WMTreeNode* WMFindInTree(WMTreeNode *aTree, WMMatchDataProc *match, void *cdata);
+
+/* Returns the first node where node's data matches cdata by 'match' and node is
+ * at most `limit' depths down from `aTree'. */
+WMTreeNode *WMFindInTreeWithDepthLimit(WMTreeNode * aTree, WMMatchDataProc * match, void *cdata, int limit);
+
+/* Returns first tree node that has data == cdata */
+#define WMGetFirstInTree(aTree, cdata) WMFindInTree(aTree, NULL, cdata)
+
+/* Walk every node of aNode with `walk' */
+void WMTreeWalk(WMTreeNode *aNode, WMTreeWalkProc * walk, void *data, Bool DepthFirst);
+
+/* ---[ WINGs/data.c ]---------------------------------------------------- */
+
+
+WMNotification* WMCreateNotification(const char *name, void *object, void *clientData);
+
+void WMReleaseNotification(WMNotification *notification);
+
+WMNotification* WMRetainNotification(WMNotification *notification);
+
+void* WMGetNotificationClientData(WMNotification *notification);
+
+void* WMGetNotificationObject(WMNotification *notification);
+
+const char* WMGetNotificationName(WMNotification *notification);
+
+
+void WMAddNotificationObserver(WMNotificationObserverAction *observerAction,
+                               void *observer, const char *name, void *object);
+
+void WMPostNotification(WMNotification *notification);
+
+void WMRemoveNotificationObserver(void *observer);
+
+void WMRemoveNotificationObserverWithName(void *observer, const char *name,
+                                          void *object);
+
+void WMPostNotificationName(const char *name, void *object, void *clientData);
+
+WMNotificationQueue* WMGetDefaultNotificationQueue(void);
+
+WMNotificationQueue* WMCreateNotificationQueue(void);
+
+void WMDequeueNotificationMatching(WMNotificationQueue *queue,
+                                   WMNotification *notification,
+                                   unsigned mask);
+
+void WMEnqueueNotification(WMNotificationQueue *queue,
+                           WMNotification *notification,
+                           WMPostingStyle postingStyle);
+
+void WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
+                                   WMNotification *notification,
+                                   WMPostingStyle postingStyle,
+                                   unsigned coalesceMask);
+
+
+/* ---[ WINGs/proplist.c ]------------------------------------------------ */
+
+/* Property Lists handling */
+
+void WMPLSetCaseSensitive(Bool caseSensitive);
+
+WMPropList* WMCreatePLString(const char *str);
+
+WMPropList* WMCreatePLData(WMData *data);
+
+WMPropList* WMCreatePLDataWithBytes(const unsigned char *bytes, unsigned int length);
+
+WMPropList* WMCreatePLDataWithBytesNoCopy(unsigned char *bytes,
+                                          unsigned int length,
+                                          WMFreeDataProc *destructor);
+
+WMPropList* WMCreatePLArray(WMPropList *elem, ...);
+
+WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value, ...);
+
+WMPropList* WMRetainPropList(WMPropList *plist);
+
+void WMReleasePropList(WMPropList *plist);
+
+/* Objects inserted in arrays and dictionaries will be retained,
+ * so you can safely release them after insertion.
+ * For dictionaries both the key and value are retained.
+ * Objects removed from arrays or dictionaries are released */
+void WMInsertInPLArray(WMPropList *plist, int index, WMPropList *item);
+
+void WMAddToPLArray(WMPropList *plist, WMPropList *item);
+
+void WMDeleteFromPLArray(WMPropList *plist, int index);
+
+void WMRemoveFromPLArray(WMPropList *plist, WMPropList *item);
+
+void WMPutInPLDictionary(WMPropList *plist, WMPropList *key, WMPropList *value);
+
+void WMRemoveFromPLDictionary(WMPropList *plist, WMPropList *key);
+
+/* It will insert all key/value pairs from source into dest, overwriting
+ * the values with the same keys from dest, keeping all values with keys
+ * only present in dest unchanged */
+WMPropList* WMMergePLDictionaries(WMPropList *dest, WMPropList *source,
+                                  Bool recursive);
+
+/* It will remove all key/value pairs from dest for which there is an
+ * identical key/value present in source. Entires only present in dest, or
+ * which have different values in dest than in source will be preserved. */
+WMPropList* WMSubtractPLDictionaries(WMPropList *dest, WMPropList *source,
+                                     Bool recursive);
+
+int WMGetPropListItemCount(WMPropList *plist);
+
+Bool WMIsPLString(WMPropList *plist);
+
+Bool WMIsPLData(WMPropList *plist);
+
+Bool WMIsPLArray(WMPropList *plist);
+
+Bool WMIsPLDictionary(WMPropList *plist);
+
+Bool WMIsPropListEqualTo(WMPropList *plist, WMPropList *other);
+
+/* Returns a reference. Do not free it! */
+char* WMGetFromPLString(WMPropList *plist);
+
+/* Returns a reference. Do not free it! */
+WMData* WMGetFromPLData(WMPropList *plist);
+
+/* Returns a reference. Do not free it! */
+const unsigned char* WMGetPLDataBytes(WMPropList *plist);
+
+int WMGetPLDataLength(WMPropList *plist);
+
+/* Returns a reference. */
+WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
+
+/* Returns a reference. */
+WMPropList* WMGetFromPLDictionary(WMPropList *plist, WMPropList *key);
+
+/* Returns a PropList array with all the dictionary keys. Release it when
+ * you're done. Keys in array are retained from the original dictionary
+ * not copied and need NOT to be released individually. */
+WMPropList* WMGetPLDictionaryKeys(WMPropList *plist);
+
+/* Creates only the first level deep object. All the elements inside are
+ * retained from the original */
+WMPropList* WMShallowCopyPropList(WMPropList *plist);
+
+/* Makes a completely separate replica of the original proplist */
+WMPropList* WMDeepCopyPropList(WMPropList *plist);
+
+WMPropList* WMCreatePropListFromDescription(const char *desc);
+
+/* Free the returned string when you no longer need it */
+char* WMGetPropListDescription(WMPropList *plist, Bool indented);
+
+WMPropList* WMReadPropListFromFile(const char *file);
+
+WMPropList* WMReadPropListFromPipe(const char *command);
+
+Bool WMWritePropListToFile(WMPropList *plist, const char *path);
+
+/* ---[ WINGs/userdefaults.c ]-------------------------------------------- */
+
+/* don't free the returned string */
+const char* wusergnusteppath(void);
+const char* wuserdatapath(void);
+
+/* Free the returned string when you no longer need it */
+char* wdefaultspathfordomain(const char *domain);
+
+/* Free the returned string when you no longer need it */
+char* wglobaldefaultspathfordomain(const char *domain);
+
+WMUserDefaults* WMGetStandardUserDefaults(void);
+
+WMUserDefaults* WMGetDefaultsFromPath(const char *path);
+
+void WMSynchronizeUserDefaults(WMUserDefaults *database);
+
+void WMSaveUserDefaults(WMUserDefaults *database);
+
+void WMEnableUDPeriodicSynchronization(WMUserDefaults *database, Bool enable);
+
+/* Returns a WMPropList array with all the keys in the user defaults database.
+ * Free the array with WMReleasePropList() when no longer needed.
+ * Keys in array are just retained references to the original keys */
+WMPropList* WMGetUDKeys(WMUserDefaults *database);
+
+WMPropList* WMGetUDObjectForKey(WMUserDefaults *database, const char *defaultName);
+
+void WMSetUDObjectForKey(WMUserDefaults *database, WMPropList *object,
+                         const char *defaultName);
+
+void WMRemoveUDObjectForKey(WMUserDefaults *database, const char *defaultName);
+
+/* Returns a reference. Do not free it! */
+char* WMGetUDStringForKey(WMUserDefaults *database, const char *defaultName);
+
+int WMGetUDIntegerForKey(WMUserDefaults *database, const char *defaultName);
+
+float WMGetUDFloatForKey(WMUserDefaults *database, const char *defaultName);
+
+Bool WMGetUDBoolForKey(WMUserDefaults *database, const char *defaultName);
+
+void WMSetUDStringForKey(WMUserDefaults *database, const char *value,
+                         const char *defaultName);
+
+void WMSetUDIntegerForKey(WMUserDefaults *database, int value,
+                          const char *defaultName);
+
+void WMSetUDFloatForKey(WMUserDefaults *database, float value,
+                        const char *defaultName);
+
+void WMSetUDBoolForKey(WMUserDefaults *database, Bool value,
+                       const char *defaultName);
+
+WMPropList* WMGetUDSearchList(WMUserDefaults *database);
+
+void WMSetUDSearchList(WMUserDefaults *database, WMPropList *list);
+
+extern char *WMUserDefaultsDidChangeNotification;
+
+
+/* ---[ WINGs/menuparser.c ]---------------------------------------------- */
+
+
+typedef struct w_menu_parser *WMenuParser;
+
+
+WMenuParser WMenuParserCreate(const char *file_name, void *file, const char *include_default_paths);
+
+void WMenuParserRegisterSimpleMacro(WMenuParser parser, const char *name, const char *value);
+
+void WMenuParserError(WMenuParser parser, const char *msg, ...)
+	__attribute__ ((format (printf, 2, 3)));
+
+const char *WMenuParserGetFilename(WMenuParser parser);
+
+Bool WMenuParserGetLine(WMenuParser parser, char **title, char **command, char **parameter, char **shortcut);
+
+void WMenuParserDelete(WMenuParser parser);
+
+
+/*-------------------------------------------------------------------------*/
+
+/* Global variables */
+
+extern int WCErrorCode;
+
+
+/*-------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif

bazel/WINGs/array.c

@@ -0,0 +1,363 @@
+/*
+ * Dynamically Resized Array
+ *
+ * Authors: Alfredo K. Kojima <kojima@windowmaker.info>
+ *          Dan Pascu         <dan@windowmaker.info>
+ *
+ * This code is released to the Public Domain, but
+ * proper credit is always appreciated :)
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "WINGs/WUtil.h"
+
+#define INITIAL_SIZE 8
+#define RESIZE_INCREMENT 8
+
+typedef struct W_Array {
+	void **items;		/* the array data */
+	int itemCount;		/* # of items in array */
+	int allocSize;		/* allocated size of array */
+	WMFreeDataProc *destructor;	/* the destructor to free elements */
+} W_Array;
+
+WMArray *WMCreateArray(int initialSize)
+{
+	return WMCreateArrayWithDestructor(initialSize, NULL);
+}
+
+WMArray *WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc * destructor)
+{
+	WMArray *array;
+
+	array = wmalloc(sizeof(WMArray));
+
+	if (initialSize <= 0) {
+		initialSize = INITIAL_SIZE;
+	}
+
+	array->items = wmalloc(sizeof(void *) * initialSize);
+
+	array->itemCount = 0;
+	array->allocSize = initialSize;
+	array->destructor = destructor;
+
+	return array;
+}
+
+WMArray *WMCreateArrayWithArray(WMArray * array)
+{
+	WMArray *newArray;
+
+	newArray = wmalloc(sizeof(WMArray));
+
+	newArray->items = wmalloc(sizeof(void *) * array->allocSize);
+	memcpy(newArray->items, array->items, sizeof(void *) * array->itemCount);
+
+	newArray->itemCount = array->itemCount;
+	newArray->allocSize = array->allocSize;
+	newArray->destructor = NULL;
+
+	return newArray;
+}
+
+void WMEmptyArray(WMArray * array)
+{
+	if (array->destructor) {
+		while (array->itemCount > 0) {
+			array->itemCount--;
+			array->destructor(array->items[array->itemCount]);
+		}
+	}
+	/*memset(array->items, 0, array->itemCount * sizeof(void*)); */
+	array->itemCount = 0;
+}
+
+void WMFreeArray(WMArray * array)
+{
+	if (array == NULL)
+		return;
+
+	WMEmptyArray(array);
+	wfree(array->items);
+	wfree(array);
+}
+
+int WMGetArrayItemCount(WMArray * array)
+{
+	if (array == NULL)
+		return 0;
+
+	return array->itemCount;
+}
+
+void WMAppendArray(WMArray * array, WMArray * other)
+{
+	if (array == NULL || other == NULL)
+		return;
+
+	if (other->itemCount == 0)
+		return;
+
+	if (array->itemCount + other->itemCount > array->allocSize) {
+		array->allocSize += other->allocSize;
+		array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
+	}
+
+	memcpy(array->items + array->itemCount, other->items, sizeof(void *) * other->itemCount);
+	array->itemCount += other->itemCount;
+}
+
+void WMAddToArray(WMArray * array, void *item)
+{
+	if (array == NULL)
+		return;
+
+	if (array->itemCount >= array->allocSize) {
+		array->allocSize += RESIZE_INCREMENT;
+		array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
+	}
+	array->items[array->itemCount] = item;
+
+	array->itemCount++;
+}
+
+void WMInsertInArray(WMArray * array, int index, void *item)
+{
+	if (array == NULL)
+		return;
+
+	wassertr(index >= 0 && index <= array->itemCount);
+
+	if (array->itemCount >= array->allocSize) {
+		array->allocSize += RESIZE_INCREMENT;
+		array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
+	}
+	if (index < array->itemCount) {
+		memmove(array->items + index + 1, array->items + index,
+			sizeof(void *) * (array->itemCount - index));
+	}
+	array->items[index] = item;
+
+	array->itemCount++;
+}
+
+void *WMReplaceInArray(WMArray * array, int index, void *item)
+{
+	void *old;
+
+	if (array == NULL)
+		return NULL;
+
+	wassertrv(index >= 0 && index <= array->itemCount, NULL);
+
+	/* is it really useful to perform append if index == array->itemCount ? -Dan */
+	if (index == array->itemCount) {
+		WMAddToArray(array, item);
+		return NULL;
+	}
+
+	old = array->items[index];
+	array->items[index] = item;
+
+	return old;
+}
+
+int WMDeleteFromArray(WMArray * array, int index)
+{
+	if (array == NULL)
+		return 0;
+
+	wassertrv(index >= 0 && index < array->itemCount, 0);
+
+	if (array->destructor) {
+		array->destructor(array->items[index]);
+	}
+
+	if (index < array->itemCount - 1) {
+		memmove(array->items + index, array->items + index + 1,
+			sizeof(void *) * (array->itemCount - index - 1));
+	}
+
+	array->itemCount--;
+
+	return 1;
+}
+
+int WMRemoveFromArrayMatching(WMArray * array, WMMatchDataProc * match, void *cdata)
+{
+	int i;
+
+	if (array == NULL)
+		return 1;
+
+	if (match != NULL) {
+		for (i = 0; i < array->itemCount; i++) {
+			if ((*match) (array->items[i], cdata)) {
+				WMDeleteFromArray(array, i);
+				return 1;
+			}
+		}
+	} else {
+		for (i = 0; i < array->itemCount; i++) {
+			if (array->items[i] == cdata) {
+				WMDeleteFromArray(array, i);
+				return 1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+void *WMGetFromArray(WMArray * array, int index)
+{
+	if (index < 0 || array == NULL || index >= array->itemCount)
+		return NULL;
+
+	return array->items[index];
+}
+
+void *WMPopFromArray(WMArray * array)
+{
+	if (array == NULL || array->itemCount <= 0)
+		return NULL;
+
+	array->itemCount--;
+
+	return array->items[array->itemCount];
+}
+
+int WMFindInArray(WMArray * array, WMMatchDataProc * match, void *cdata)
+{
+	int i;
+
+	if (array == NULL)
+		return WANotFound;
+
+	if (match != NULL) {
+		for (i = 0; i < array->itemCount; i++) {
+			if ((*match) (array->items[i], cdata))
+				return i;
+		}
+	} else {
+		for (i = 0; i < array->itemCount; i++) {
+			if (array->items[i] == cdata)
+				return i;
+		}
+	}
+
+	return WANotFound;
+}
+
+int WMCountInArray(WMArray * array, void *item)
+{
+	int i, count;
+
+	if (array == NULL)
+		return 0;
+
+	for (i = 0, count = 0; i < array->itemCount; i++) {
+		if (array->items[i] == item)
+			count++;
+	}
+
+	return count;
+}
+
+void WMSortArray(WMArray * array, WMCompareDataProc * comparer)
+{
+	if (array == NULL)
+		return;
+
+	if (array->itemCount > 1) {	/* Don't sort empty or single element arrays */
+		qsort(array->items, array->itemCount, sizeof(void *), comparer);
+	}
+}
+
+void WMMapArray(WMArray * array, void (*function) (void *, void *), void *data)
+{
+	int i;
+
+	if (array == NULL)
+		return;
+
+	for (i = 0; i < array->itemCount; i++) {
+		(*function) (array->items[i], data);
+	}
+}
+
+WMArray *WMGetSubarrayWithRange(WMArray * array, WMRange aRange)
+{
+	WMArray *newArray;
+
+	if (aRange.count <= 0 || array == NULL)
+		return WMCreateArray(0);
+
+	if (aRange.position < 0)
+		aRange.position = 0;
+	if (aRange.position >= array->itemCount)
+		aRange.position = array->itemCount - 1;
+	if (aRange.position + aRange.count > array->itemCount)
+		aRange.count = array->itemCount - aRange.position;
+
+	newArray = WMCreateArray(aRange.count);
+	memcpy(newArray->items, array->items + aRange.position, sizeof(void *) * aRange.count);
+	newArray->itemCount = aRange.count;
+
+	return newArray;
+}
+
+void *WMArrayFirst(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL || array->itemCount == 0) {
+		*iter = WANotFound;
+		return NULL;
+	} else {
+		*iter = 0;
+		return array->items[0];
+	}
+}
+
+void *WMArrayLast(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL || array->itemCount == 0) {
+		*iter = WANotFound;
+		return NULL;
+	} else {
+		*iter = array->itemCount - 1;
+		return array->items[*iter];
+	}
+}
+
+void *WMArrayNext(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL) {
+		*iter = WANotFound;
+		return NULL;
+	}
+
+	if (*iter >= 0 && *iter < array->itemCount - 1) {
+		return array->items[++(*iter)];
+	} else {
+		*iter = WANotFound;
+		return NULL;
+	}
+}
+
+void *WMArrayPrevious(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL) {
+		*iter = WANotFound;
+		return NULL;
+	}
+
+	if (*iter > 0 && *iter < array->itemCount) {
+		return array->items[--(*iter)];
+	} else {
+		*iter = WANotFound;
+		return NULL;
+	}
+}

bazel/WINGs/bagtree.c

@@ -0,0 +1,745 @@
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "WUtil.h"
+
+typedef struct W_Node {
+	struct W_Node *parent;
+	struct W_Node *left;
+	struct W_Node *right;
+	int color;
+
+	void *data;
+	int index;
+} W_Node;
+
+typedef struct W_Bag {
+	W_Node *root;
+
+	W_Node *nil;		/* sentinel */
+
+	int count;
+
+	void (*destructor) (void *item);
+} W_Bag;
+
+#define IS_LEFT(node) (node == node->parent->left)
+#define IS_RIGHT(node) (node == node->parent->right)
+
+static void leftRotate(W_Bag * tree, W_Node * node)
+{
+	W_Node *node2;
+
+	node2 = node->right;
+	node->right = node2->left;
+
+	node2->left->parent = node;
+
+	node2->parent = node->parent;
+
+	if (node->parent == tree->nil) {
+		tree->root = node2;
+	} else {
+		if (IS_LEFT(node)) {
+			node->parent->left = node2;
+		} else {
+			node->parent->right = node2;
+		}
+	}
+	node2->left = node;
+	node->parent = node2;
+}
+
+static void rightRotate(W_Bag * tree, W_Node * node)
+{
+	W_Node *node2;
+
+	node2 = node->left;
+	node->left = node2->right;
+
+	node2->right->parent = node;
+
+	node2->parent = node->parent;
+
+	if (node->parent == tree->nil) {
+		tree->root = node2;
+	} else {
+		if (IS_LEFT(node)) {
+			node->parent->left = node2;
+		} else {
+			node->parent->right = node2;
+		}
+	}
+	node2->right = node;
+	node->parent = node2;
+}
+
+static void treeInsert(W_Bag * tree, W_Node * node)
+{
+	W_Node *y = tree->nil;
+	W_Node *x = tree->root;
+
+	while (x != tree->nil) {
+		y = x;
+		if (node->index <= x->index)
+			x = x->left;
+		else
+			x = x->right;
+	}
+	node->parent = y;
+	if (y == tree->nil)
+		tree->root = node;
+	else if (node->index <= y->index)
+		y->left = node;
+	else
+		y->right = node;
+}
+
+static void rbTreeInsert(W_Bag * tree, W_Node * node)
+{
+	W_Node *y;
+
+	treeInsert(tree, node);
+
+	node->color = 'R';
+
+	while (node != tree->root && node->parent->color == 'R') {
+		if (IS_LEFT(node->parent)) {
+			y = node->parent->parent->right;
+
+			if (y->color == 'R') {
+
+				node->parent->color = 'B';
+				y->color = 'B';
+				node->parent->parent->color = 'R';
+				node = node->parent->parent;
+
+			} else {
+				if (IS_RIGHT(node)) {
+					node = node->parent;
+					leftRotate(tree, node);
+				}
+				node->parent->color = 'B';
+				node->parent->parent->color = 'R';
+				rightRotate(tree, node->parent->parent);
+			}
+		} else {
+			y = node->parent->parent->left;
+
+			if (y->color == 'R') {
+
+				node->parent->color = 'B';
+				y->color = 'B';
+				node->parent->parent->color = 'R';
+				node = node->parent->parent;
+
+			} else {
+				if (IS_LEFT(node)) {
+					node = node->parent;
+					rightRotate(tree, node);
+				}
+				node->parent->color = 'B';
+				node->parent->parent->color = 'R';
+				leftRotate(tree, node->parent->parent);
+			}
+		}
+	}
+	tree->root->color = 'B';
+}
+
+static void rbDeleteFixup(W_Bag * tree, W_Node * node)
+{
+	W_Node *w;
+
+	while (node != tree->root && node->color == 'B') {
+		if (IS_LEFT(node)) {
+			w = node->parent->right;
+			if (w->color == 'R') {
+				w->color = 'B';
+				node->parent->color = 'R';
+				leftRotate(tree, node->parent);
+				w = node->parent->right;
+			}
+			if (w->left->color == 'B' && w->right->color == 'B') {
+				w->color = 'R';
+				node = node->parent;
+			} else {
+				if (w->right->color == 'B') {
+					w->left->color = 'B';
+					w->color = 'R';
+					rightRotate(tree, w);
+					w = node->parent->right;
+				}
+				w->color = node->parent->color;
+				node->parent->color = 'B';
+				w->right->color = 'B';
+				leftRotate(tree, node->parent);
+				node = tree->root;
+			}
+		} else {
+			w = node->parent->left;
+			if (w->color == 'R') {
+				w->color = 'B';
+				node->parent->color = 'R';
+				rightRotate(tree, node->parent);
+				w = node->parent->left;
+			}
+			if (w->left->color == 'B' && w->right->color == 'B') {
+				w->color = 'R';
+				node = node->parent;
+			} else {
+				if (w->left->color == 'B') {
+					w->right->color = 'B';
+					w->color = 'R';
+					leftRotate(tree, w);
+					w = node->parent->left;
+				}
+				w->color = node->parent->color;
+				node->parent->color = 'B';
+				w->left->color = 'B';
+				rightRotate(tree, node->parent);
+				node = tree->root;
+			}
+		}
+	}
+	node->color = 'B';
+
+}
+
+static W_Node *treeMinimum(W_Node * node, W_Node * nil)
+{
+	while (node->left != nil)
+		node = node->left;
+	return node;
+}
+
+static W_Node *treeMaximum(W_Node * node, W_Node * nil)
+{
+	while (node->right != nil)
+		node = node->right;
+	return node;
+}
+
+static W_Node *treeSuccessor(W_Node * node, W_Node * nil)
+{
+	W_Node *y;
+
+	if (node->right != nil) {
+		return treeMinimum(node->right, nil);
+	}
+	y = node->parent;
+	while (y != nil && node == y->right) {
+		node = y;
+		y = y->parent;
+	}
+	return y;
+}
+
+static W_Node *treePredecessor(W_Node * node, W_Node * nil)
+{
+	W_Node *y;
+
+	if (node->left != nil) {
+		return treeMaximum(node->left, nil);
+	}
+	y = node->parent;
+	while (y != nil && node == y->left) {
+		node = y;
+		y = y->parent;
+	}
+	return y;
+}
+
+static W_Node *rbTreeDelete(W_Bag * tree, W_Node * node)
+{
+	W_Node *nil = tree->nil;
+	W_Node *x, *y;
+
+	if (node->left == nil || node->right == nil) {
+		y = node;
+	} else {
+		y = treeSuccessor(node, nil);
+	}
+
+	if (y->left != nil) {
+		x = y->left;
+	} else {
+		x = y->right;
+	}
+
+	x->parent = y->parent;
+
+	if (y->parent == nil) {
+		tree->root = x;
+	} else {
+		if (IS_LEFT(y)) {
+			y->parent->left = x;
+		} else {
+			y->parent->right = x;
+		}
+	}
+	if (y != node) {
+		node->index = y->index;
+		node->data = y->data;
+	}
+	if (y->color == 'B') {
+		rbDeleteFixup(tree, x);
+	}
+
+	return y;
+}
+
+static W_Node *treeSearch(W_Node * root, W_Node * nil, int index)
+{
+	if (root == nil || root->index == index) {
+		return root;
+	}
+
+	if (index < root->index) {
+		return treeSearch(root->left, nil, index);
+	} else {
+		return treeSearch(root->right, nil, index);
+	}
+}
+
+static W_Node *treeFind(W_Node * root, W_Node * nil, void *data)
+{
+	W_Node *tmp;
+
+	if (root == nil || root->data == data)
+		return root;
+
+	tmp = treeFind(root->left, nil, data);
+	if (tmp != nil)
+		return tmp;
+
+	tmp = treeFind(root->right, nil, data);
+
+	return tmp;
+}
+
+#if 0
+static char buf[512];
+
+static void printNodes(W_Node * node, W_Node * nil, int depth)
+{
+	if (node == nil) {
+		return;
+	}
+
+	printNodes(node->left, nil, depth + 1);
+
+	memset(buf, ' ', depth * 2);
+	buf[depth * 2] = 0;
+	if (IS_LEFT(node))
+		printf("%s/(%2i\n", buf, node->index);
+	else
+		printf("%s\\(%2i\n", buf, node->index);
+
+	printNodes(node->right, nil, depth + 1);
+}
+
+void PrintTree(WMBag * bag)
+{
+	W_TreeBag *tree = (W_TreeBag *) bag->data;
+
+	printNodes(tree->root, tree->nil, 0);
+}
+#endif
+
+WMBag *WMCreateTreeBag(void)
+{
+	return WMCreateTreeBagWithDestructor(NULL);
+}
+
+WMBag *WMCreateTreeBagWithDestructor(WMFreeDataProc * destructor)
+{
+	WMBag *bag;
+
+	bag = wmalloc(sizeof(WMBag));
+	bag->nil = wmalloc(sizeof(W_Node));
+	bag->nil->left = bag->nil->right = bag->nil->parent = bag->nil;
+	bag->nil->index = WBNotFound;
+	bag->root = bag->nil;
+	bag->destructor = destructor;
+
+	return bag;
+}
+
+int WMGetBagItemCount(WMBag * self)
+{
+	return self->count;
+}
+
+void WMAppendBag(WMBag * self, WMBag * bag)
+{
+	WMBagIterator ptr;
+	void *data;
+
+	for (data = WMBagFirst(bag, &ptr); data != NULL; data = WMBagNext(bag, &ptr)) {
+		WMPutInBag(self, data);
+	}
+}
+
+void WMPutInBag(WMBag * self, void *item)
+{
+	W_Node *ptr;
+
+	ptr = wmalloc(sizeof(W_Node));
+
+	ptr->data = item;
+	ptr->index = self->count;
+	ptr->left = self->nil;
+	ptr->right = self->nil;
+	ptr->parent = self->nil;
+
+	rbTreeInsert(self, ptr);
+
+	self->count++;
+}
+
+void WMInsertInBag(WMBag * self, int index, void *item)
+{
+	W_Node *ptr;
+
+	ptr = wmalloc(sizeof(W_Node));
+
+	ptr->data = item;
+	ptr->index = index;
+	ptr->left = self->nil;
+	ptr->right = self->nil;
+	ptr->parent = self->nil;
+
+	rbTreeInsert(self, ptr);
+
+	while ((ptr = treeSuccessor(ptr, self->nil)) != self->nil) {
+		ptr->index++;
+	}
+
+	self->count++;
+}
+
+static int treeDeleteNode(WMBag * self, W_Node *ptr)
+{
+	if (ptr != self->nil) {
+		W_Node *tmp;
+
+		self->count--;
+
+		tmp = treeSuccessor(ptr, self->nil);
+		while (tmp != self->nil) {
+			tmp->index--;
+			tmp = treeSuccessor(tmp, self->nil);
+		}
+
+		ptr = rbTreeDelete(self, ptr);
+		if (self->destructor)
+			self->destructor(ptr->data);
+		wfree(ptr);
+		return 1;
+	}
+	return 0;
+}
+
+int WMRemoveFromBag(WMBag * self, void *item)
+{
+	W_Node *ptr = treeFind(self->root, self->nil, item);
+	return treeDeleteNode(self, ptr);
+}
+
+int WMEraseFromBag(WMBag * self, int index)
+{
+	W_Node *ptr = treeSearch(self->root, self->nil, index);
+
+	if (ptr != self->nil) {
+
+		self->count--;
+
+		ptr = rbTreeDelete(self, ptr);
+		if (self->destructor)
+			self->destructor(ptr->data);
+		wfree(ptr);
+
+		wassertrv(self->count == 0 || self->root->index >= 0, 1);
+
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+int WMDeleteFromBag(WMBag * self, int index)
+{
+	W_Node *ptr = treeSearch(self->root, self->nil, index);
+	return treeDeleteNode(self, ptr);
+}
+
+void *WMGetFromBag(WMBag * self, int index)
+{
+	W_Node *node;
+
+	node = treeSearch(self->root, self->nil, index);
+	if (node != self->nil)
+		return node->data;
+	else
+		return NULL;
+}
+
+int WMGetFirstInBag(WMBag * self, void *item)
+{
+	W_Node *node;
+
+	node = treeFind(self->root, self->nil, item);
+	if (node != self->nil)
+		return node->index;
+	else
+		return WBNotFound;
+}
+
+static int treeCount(W_Node * root, W_Node * nil, void *item)
+{
+	int count = 0;
+
+	if (root == nil)
+		return 0;
+
+	if (root->data == item)
+		count++;
+
+	if (root->left != nil)
+		count += treeCount(root->left, nil, item);
+
+	if (root->right != nil)
+		count += treeCount(root->right, nil, item);
+
+	return count;
+}
+
+int WMCountInBag(WMBag * self, void *item)
+{
+	return treeCount(self->root, self->nil, item);
+}
+
+void *WMReplaceInBag(WMBag * self, int index, void *item)
+{
+	W_Node *ptr = treeSearch(self->root, self->nil, index);
+	void *old = NULL;
+
+	if (item == NULL) {
+		self->count--;
+		ptr = rbTreeDelete(self, ptr);
+		if (self->destructor)
+			self->destructor(ptr->data);
+		wfree(ptr);
+	} else if (ptr != self->nil) {
+		old = ptr->data;
+		ptr->data = item;
+	} else {
+		W_Node *ptr;
+
+		ptr = wmalloc(sizeof(W_Node));
+
+		ptr->data = item;
+		ptr->index = index;
+		ptr->left = self->nil;
+		ptr->right = self->nil;
+		ptr->parent = self->nil;
+
+		rbTreeInsert(self, ptr);
+
+		self->count++;
+	}
+
+	return old;
+}
+
+void WMSortBag(WMBag * self, WMCompareDataProc * comparer)
+{
+	void **items;
+	W_Node *tmp;
+	int i;
+
+	if (self->count == 0)
+		return;
+
+	items = wmalloc(sizeof(void *) * self->count);
+	i = 0;
+
+	tmp = treeMinimum(self->root, self->nil);
+	while (tmp != self->nil) {
+		items[i++] = tmp->data;
+		tmp = treeSuccessor(tmp, self->nil);
+	}
+
+	qsort(&items[0], self->count, sizeof(void *), comparer);
+
+	i = 0;
+	tmp = treeMinimum(self->root, self->nil);
+	while (tmp != self->nil) {
+		tmp->index = i;
+		tmp->data = items[i++];
+		tmp = treeSuccessor(tmp, self->nil);
+	}
+
+	wfree(items);
+}
+
+static void deleteTree(WMBag * self, W_Node * node)
+{
+	if (node == self->nil)
+		return;
+
+	deleteTree(self, node->left);
+
+	if (self->destructor)
+		self->destructor(node->data);
+
+	deleteTree(self, node->right);
+
+	wfree(node);
+}
+
+void WMEmptyBag(WMBag * self)
+{
+	deleteTree(self, self->root);
+	self->root = self->nil;
+	self->count = 0;
+}
+
+void WMFreeBag(WMBag * self)
+{
+	WMEmptyBag(self);
+	wfree(self->nil);
+	wfree(self);
+}
+
+static void mapTree(W_Bag * tree, W_Node * node, void (*function) (void *, void *), void *data)
+{
+	if (node == tree->nil)
+		return;
+
+	mapTree(tree, node->left, function, data);
+
+	(*function) (node->data, data);
+
+	mapTree(tree, node->right, function, data);
+}
+
+void WMMapBag(WMBag * self, void (*function) (void *, void *), void *data)
+{
+	mapTree(self, self->root, function, data);
+}
+
+static int findInTree(W_Bag * tree, W_Node * node, WMMatchDataProc * function, void *cdata)
+{
+	int index;
+
+	if (node == tree->nil)
+		return WBNotFound;
+
+	index = findInTree(tree, node->left, function, cdata);
+	if (index != WBNotFound)
+		return index;
+
+	if ((*function) (node->data, cdata)) {
+		return node->index;
+	}
+
+	return findInTree(tree, node->right, function, cdata);
+}
+
+int WMFindInBag(WMBag * self, WMMatchDataProc * match, void *cdata)
+{
+	return findInTree(self, self->root, match, cdata);
+}
+
+void *WMBagFirst(WMBag * self, WMBagIterator * ptr)
+{
+	W_Node *node;
+
+	node = treeMinimum(self->root, self->nil);
+
+	if (node == self->nil) {
+		*ptr = NULL;
+		return NULL;
+	} else {
+		*ptr = node;
+		return node->data;
+	}
+}
+
+void *WMBagLast(WMBag * self, WMBagIterator * ptr)
+{
+
+	W_Node *node;
+
+	node = treeMaximum(self->root, self->nil);
+
+	if (node == self->nil) {
+		*ptr = NULL;
+		return NULL;
+	} else {
+		*ptr = node;
+		return node->data;
+	}
+}
+
+void *WMBagNext(WMBag * self, WMBagIterator * ptr)
+{
+	W_Node *node;
+
+	if (*ptr == NULL)
+		return NULL;
+
+	node = treeSuccessor(*ptr, self->nil);
+
+	if (node == self->nil) {
+		*ptr = NULL;
+		return NULL;
+	} else {
+		*ptr = node;
+		return node->data;
+	}
+}
+
+void *WMBagPrevious(WMBag * self, WMBagIterator * ptr)
+{
+	W_Node *node;
+
+	if (*ptr == NULL)
+		return NULL;
+
+	node = treePredecessor(*ptr, self->nil);
+
+	if (node == self->nil) {
+		*ptr = NULL;
+		return NULL;
+	} else {
+		*ptr = node;
+		return node->data;
+	}
+}
+
+void *WMBagIteratorAtIndex(WMBag * self, int index, WMBagIterator * ptr)
+{
+	W_Node *node;
+
+	node = treeSearch(self->root, self->nil, index);
+
+	if (node == self->nil) {
+		*ptr = NULL;
+		return NULL;
+	} else {
+		*ptr = node;
+		return node->data;
+	}
+}
+
+int WMBagIndexForIterator(WMBag * bag, WMBagIterator ptr)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) bag;
+
+	return ((W_Node *) ptr)->index;
+}

bazel/WINGs/configuration.c

@@ -0,0 +1,132 @@
+
+#include "WINGs/WINGsP.h"
+#include "WINGs/wconfig.h"
+
+#include <X11/Xlocale.h>
+
+_WINGsConfiguration WINGsConfiguration;
+
+#define SYSTEM_FONT "sans serif"
+#define BOLD_SYSTEM_FONT "sans serif:bold"
+#define DEFAULT_FONT_SIZE 12
+
+#define FLOPPY_PATH "/floppy"
+
+static unsigned getButtonWithName(const char *name, unsigned defaultButton)
+{
+	if (strncmp(name, "Button", 6) == 0 && strlen(name) == 7) {
+		switch (name[6]) {
+		case '1':
+			return Button1;
+		case '2':
+			return Button2;
+		case '3':
+			return Button3;
+		case '4':
+			return Button4;
+		case '5':
+			return Button5;
+		default:
+			break;
+		}
+	}
+
+	return defaultButton;
+}
+
+void W_ReadConfigurations(void)
+{
+	WMUserDefaults *defaults;
+	Bool aaIsSet = False;
+
+	memset(&WINGsConfiguration, 0, sizeof(_WINGsConfiguration));
+
+	defaults = WMGetStandardUserDefaults();
+
+	if (defaults) {
+		char *buttonName;
+		WMPropList *val;
+		unsigned button;
+
+		WINGsConfiguration.systemFont = WMGetUDStringForKey(defaults, "SystemFont");
+
+		WINGsConfiguration.boldSystemFont = WMGetUDStringForKey(defaults, "BoldSystemFont");
+
+		val = WMGetUDObjectForKey(defaults, "AntialiasedText");
+		if (val && WMIsPLString(val) && WMGetFromPLString(val)) {
+			aaIsSet = True;
+			WINGsConfiguration.antialiasedText =
+				WMGetUDBoolForKey(defaults, "AntialiasedText");
+		}
+
+		WINGsConfiguration.doubleClickDelay = WMGetUDIntegerForKey(defaults, "DoubleClickTime");
+
+		WINGsConfiguration.floppyPath = WMGetUDStringForKey(defaults, "FloppyPath");
+
+		buttonName = WMGetUDStringForKey(defaults, "MouseWheelUp");
+		if (buttonName) {
+			button = getButtonWithName(buttonName, Button4);
+			wfree(buttonName);
+		} else {
+			button = Button4;
+		}
+		WINGsConfiguration.mouseWheelUp = button;
+
+		buttonName = WMGetUDStringForKey(defaults, "MouseWheelDown");
+		if (buttonName) {
+			button = getButtonWithName(buttonName, Button5);
+			wfree(buttonName);
+		} else {
+			button = Button5;
+		}
+		WINGsConfiguration.mouseWheelDown = button;
+
+		if (WINGsConfiguration.mouseWheelDown == WINGsConfiguration.mouseWheelUp) {
+			WINGsConfiguration.mouseWheelUp = Button4;
+			WINGsConfiguration.mouseWheelDown = Button5;
+		}
+
+		WINGsConfiguration.defaultFontSize = WMGetUDIntegerForKey(defaults, "DefaultFontSize");
+	}
+
+	if (!WINGsConfiguration.systemFont) {
+		WINGsConfiguration.systemFont = SYSTEM_FONT;
+	}
+	if (!WINGsConfiguration.boldSystemFont) {
+		WINGsConfiguration.boldSystemFont = BOLD_SYSTEM_FONT;
+	}
+	if (WINGsConfiguration.defaultFontSize == 0) {
+		WINGsConfiguration.defaultFontSize = DEFAULT_FONT_SIZE;
+	}
+	if (!aaIsSet) {
+		WINGsConfiguration.antialiasedText = True;
+	}
+	if (!WINGsConfiguration.floppyPath) {
+		WINGsConfiguration.floppyPath = FLOPPY_PATH;
+	}
+	if (WINGsConfiguration.doubleClickDelay == 0) {
+		WINGsConfiguration.doubleClickDelay = 250;
+	}
+	if (WINGsConfiguration.mouseWheelUp == 0) {
+		WINGsConfiguration.mouseWheelUp = Button4;
+	}
+	if (WINGsConfiguration.mouseWheelDown == 0) {
+		WINGsConfiguration.mouseWheelDown = Button5;
+	}
+
+}
+
+unsigned W_getconf_mouseWheelUp(void)
+{
+	return WINGsConfiguration.mouseWheelUp;
+}
+
+unsigned W_getconf_mouseWheelDown(void)
+{
+	return WINGsConfiguration.mouseWheelDown;
+}
+
+void W_setconf_doubleClickDelay(int value)
+{
+	WINGsConfiguration.doubleClickDelay = value;
+}

bazel/WINGs/data.c

@@ -0,0 +1,289 @@
+/*
+ *  WINGs WMData function library
+ *
+ *  Copyright (c) 1999-2003 Dan Pascu
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ *  MA 02110-1301, USA.
+ */
+
+#include <string.h>
+#include "WUtil.h"
+
+typedef struct W_Data {
+	unsigned length;	/* How many bytes we have */
+	unsigned capacity;	/* How many bytes it can hold */
+	unsigned growth;	/* How much to grow */
+	void *bytes;		/* Actual data */
+	unsigned retainCount;
+	WMFreeDataProc *destructor;
+	int format;		/* 0, 8, 16 or 32 */
+} W_Data;
+
+/* Creating and destroying data objects */
+
+WMData *WMCreateDataWithCapacity(unsigned capacity)
+{
+	WMData *aData;
+
+	aData = (WMData *) wmalloc(sizeof(WMData));
+
+	if (capacity > 0)
+		aData->bytes = wmalloc(capacity);
+	else
+		aData->bytes = NULL;
+
+	aData->capacity = capacity;
+	aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
+	aData->length = 0;
+	aData->retainCount = 1;
+	aData->format = 0;
+	aData->destructor = wfree;
+
+	return aData;
+}
+
+WMData *WMCreateDataWithLength(unsigned length)
+{
+	WMData *aData;
+
+	aData = WMCreateDataWithCapacity(length);
+	if (length > 0) {
+		aData->length = length;
+	}
+
+	return aData;
+}
+
+WMData *WMCreateDataWithBytes(const void *bytes, unsigned length)
+{
+	WMData *aData;
+
+	aData = WMCreateDataWithCapacity(length);
+	aData->length = length;
+	memcpy(aData->bytes, bytes, length);
+
+	return aData;
+}
+
+WMData *WMCreateDataWithBytesNoCopy(void *bytes, unsigned length, WMFreeDataProc * destructor)
+{
+	WMData *aData;
+
+	aData = (WMData *) wmalloc(sizeof(WMData));
+	aData->length = length;
+	aData->capacity = length;
+	aData->growth = length / 2 > 0 ? length / 2 : 1;
+	aData->bytes = bytes;
+	aData->retainCount = 1;
+	aData->format = 0;
+	aData->destructor = destructor;
+
+	return aData;
+}
+
+WMData *WMCreateDataWithData(WMData * aData)
+{
+	WMData *newData;
+
+	if (aData->length > 0) {
+		newData = WMCreateDataWithBytes(aData->bytes, aData->length);
+	} else {
+		newData = WMCreateDataWithCapacity(0);
+	}
+	newData->format = aData->format;
+
+	return newData;
+}
+
+WMData *WMRetainData(WMData * aData)
+{
+	aData->retainCount++;
+	return aData;
+}
+
+void WMReleaseData(WMData * aData)
+{
+	aData->retainCount--;
+	if (aData->retainCount > 0)
+		return;
+	if (aData->bytes != NULL && aData->destructor != NULL) {
+		aData->destructor(aData->bytes);
+	}
+	wfree(aData);
+}
+
+/* Adjusting capacity */
+
+void WMSetDataCapacity(WMData * aData, unsigned capacity)
+{
+	if (aData->capacity != capacity) {
+		aData->bytes = wrealloc(aData->bytes, capacity);
+		aData->capacity = capacity;
+		aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
+	}
+	if (aData->length > capacity) {
+		aData->length = capacity;
+	}
+}
+
+void WMSetDataLength(WMData * aData, unsigned length)
+{
+	if (length > aData->capacity) {
+		WMSetDataCapacity(aData, length);
+	}
+	if (length > aData->length) {
+		memset((unsigned char *)aData->bytes + aData->length, 0, length - aData->length);
+	}
+	aData->length = length;
+}
+
+void WMSetDataFormat(WMData * aData, unsigned format)
+{
+	aData->format = format;
+}
+
+void WMIncreaseDataLengthBy(WMData * aData, unsigned extraLength)
+{
+	WMSetDataLength(aData, aData->length + extraLength);
+}
+
+/* Accessing data */
+
+const void *WMDataBytes(WMData * aData)
+{
+	return aData->bytes;
+}
+
+void WMGetDataBytes(WMData * aData, void *buffer)
+{
+	wassertr(aData->length > 0);
+
+	memcpy(buffer, aData->bytes, aData->length);
+}
+
+unsigned WMGetDataFormat(WMData * aData)
+{
+	return aData->format;
+}
+
+void WMGetDataBytesWithLength(WMData * aData, void *buffer, unsigned length)
+{
+	wassertr(aData->length > 0);
+	wassertr(length <= aData->length);
+
+	memcpy(buffer, aData->bytes, length);
+}
+
+void WMGetDataBytesWithRange(WMData * aData, void *buffer, WMRange aRange)
+{
+	wassertr(aRange.position < aData->length);
+	wassertr(aRange.count <= aData->length - aRange.position);
+
+	memcpy(buffer, (unsigned char *)aData->bytes + aRange.position, aRange.count);
+}
+
+WMData *WMGetSubdataWithRange(WMData * aData, WMRange aRange)
+{
+	void *buffer;
+	WMData *newData;
+
+	if (aRange.count <= 0)
+		return WMCreateDataWithCapacity(0);
+
+	buffer = wmalloc(aRange.count);
+	WMGetDataBytesWithRange(aData, buffer, aRange);
+	newData = WMCreateDataWithBytesNoCopy(buffer, aRange.count, wfree);
+	newData->format = aData->format;
+
+	return newData;
+}
+
+/* Testing data */
+
+Bool WMIsDataEqualToData(WMData * aData, WMData * anotherData)
+{
+	if (aData->length != anotherData->length)
+		return False;
+	else if (!aData->bytes && !anotherData->bytes)	/* both are empty */
+		return True;
+	else if (!aData->bytes || !anotherData->bytes)	/* one of them is empty */
+		return False;
+	return (memcmp(aData->bytes, anotherData->bytes, aData->length) == 0);
+}
+
+unsigned WMGetDataLength(WMData * aData)
+{
+	return aData->length;
+}
+
+/* Adding data */
+void WMAppendDataBytes(WMData * aData, const void *bytes, unsigned length)
+{
+	unsigned oldLength = aData->length;
+	unsigned newLength = oldLength + length;
+
+	if (newLength > aData->capacity) {
+		unsigned nextCapacity = aData->capacity + aData->growth;
+		unsigned nextGrowth = aData->capacity ? aData->capacity : 1;
+
+		while (nextCapacity < newLength) {
+			unsigned tmp = nextCapacity + nextGrowth;
+
+			nextGrowth = nextCapacity;
+			nextCapacity = tmp;
+		}
+		WMSetDataCapacity(aData, nextCapacity);
+		aData->growth = nextGrowth;
+	}
+	memcpy((unsigned char *)aData->bytes + oldLength, bytes, length);
+	aData->length = newLength;
+}
+
+void WMAppendData(WMData * aData, WMData * anotherData)
+{
+	if (anotherData->length > 0)
+		WMAppendDataBytes(aData, anotherData->bytes, anotherData->length);
+}
+
+/* Modifying data */
+
+void WMReplaceDataBytesInRange(WMData * aData, WMRange aRange, const void *bytes)
+{
+	wassertr(aRange.position < aData->length);
+	wassertr(aRange.count <= aData->length - aRange.position);
+
+	memcpy((unsigned char *)aData->bytes + aRange.position, bytes, aRange.count);
+}
+
+void WMResetDataBytesInRange(WMData * aData, WMRange aRange)
+{
+	wassertr(aRange.position < aData->length);
+	wassertr(aRange.count <= aData->length - aRange.position);
+
+	memset((unsigned char *)aData->bytes + aRange.position, 0, aRange.count);
+}
+
+void WMSetData(WMData * aData, WMData * anotherData)
+{
+	unsigned length = anotherData->length;
+
+	WMSetDataCapacity(aData, length);
+	if (length > 0)
+		memcpy(aData->bytes, anotherData->bytes, length);
+	aData->length = length;
+}
+
+/* Storing data */

bazel/WINGs/dragcommon.c

@@ -0,0 +1,259 @@
+#include "wconfig.h"
+
+#include "WINGs/WINGsP.h"
+
+#define XDND_SOURCE_VERSION(dragInfo) dragInfo->protocolVersion
+#define XDND_DEST_INFO(dragInfo) dragInfo->destInfo
+#define XDND_DEST_VIEW(dragInfo) dragInfo->destInfo->destView
+
+static Bool _WindowExists;
+
+Atom W_OperationToAction(WMScreen * scr, WMDragOperationType operation)
+{
+	switch (operation) {
+	case WDOperationNone:
+		return None;
+
+	case WDOperationCopy:
+		return scr->xdndActionCopy;
+
+	case WDOperationMove:
+		return scr->xdndActionMove;
+
+	case WDOperationLink:
+		return scr->xdndActionLink;
+
+	case WDOperationAsk:
+		return scr->xdndActionAsk;
+
+	case WDOperationPrivate:
+		return scr->xdndActionPrivate;
+
+	default:
+		return None;
+	}
+}
+
+WMDragOperationType W_ActionToOperation(WMScreen * scr, Atom action)
+{
+	if (action == scr->xdndActionCopy) {
+		return WDOperationCopy;
+
+	} else if (action == scr->xdndActionMove) {
+		return WDOperationMove;
+
+	} else if (action == scr->xdndActionLink) {
+		return WDOperationLink;
+
+	} else if (action == scr->xdndActionAsk) {
+		return WDOperationAsk;
+
+	} else if (action == scr->xdndActionPrivate) {
+		return WDOperationPrivate;
+
+	} else if (action == None) {
+
+		return WDOperationNone;
+	} else {
+		char *tmp = XGetAtomName(scr->display, action);
+
+		wwarning(_("unknown XDND action %s"), tmp);
+		XFree(tmp);
+
+		return WDOperationCopy;
+	}
+}
+
+static void freeDragOperationItem(void *item)
+{
+	wfree(item);
+}
+
+WMArray *WMCreateDragOperationArray(int initialSize)
+{
+	return WMCreateArrayWithDestructor(initialSize, freeDragOperationItem);
+}
+
+WMDragOperationItem *WMCreateDragOperationItem(WMDragOperationType type, char *text)
+{
+	W_DragOperationItem *result = wmalloc(sizeof(W_DragOperationItem));
+
+	result->type = type;
+	result->text = text;
+
+	return (WMDragOperationItem *) result;
+}
+
+WMDragOperationType WMGetDragOperationItemType(WMDragOperationItem * item)
+{
+	return ((W_DragOperationItem *) item)->type;
+}
+
+char *WMGetDragOperationItemText(WMDragOperationItem * item)
+{
+	return ((W_DragOperationItem *) item)->text;
+}
+
+static int handleNoWindowXError(Display * dpy, XErrorEvent * errEvt)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) dpy;
+
+	if (errEvt->error_code == BadWindow || errEvt->error_code == BadDrawable) {
+		_WindowExists = False;
+		return Success;
+	}
+
+	return errEvt->error_code;
+}
+
+static Bool windowExists(Display * dpy, Window win)
+{
+	void *previousErrorHandler;
+	XWindowAttributes attr;
+
+	XSynchronize(dpy, True);
+	previousErrorHandler = XSetErrorHandler(handleNoWindowXError);
+	_WindowExists = True;
+
+	/* can generate BadDrawable or BadWindow */
+	XGetWindowAttributes(dpy, win, &attr);
+
+	XSetErrorHandler(previousErrorHandler);
+	XSynchronize(dpy, False);
+	return _WindowExists;
+}
+
+Bool
+W_SendDnDClientMessage(Display * dpy, Window win, Atom message,
+		       unsigned long data0,
+		       unsigned long data1, unsigned long data2, unsigned long data3, unsigned long data4)
+{
+	XEvent ev;
+
+#ifdef XDND_DEBUG
+	char *msgName = XGetAtomName(dpy, message);
+
+	printf("sending message %s ... ", msgName);
+	XFree(msgName);
+#endif
+
+	if (!windowExists(dpy, win)) {
+		wwarning(_("target %lu for XDND message no longer exists"), win);
+		return False;	/* message not sent */
+	}
+
+	ev.type = ClientMessage;
+	ev.xclient.message_type = message;
+	ev.xclient.format = 32;
+	ev.xclient.window = win;
+	ev.xclient.data.l[0] = data0;
+	ev.xclient.data.l[1] = data1;
+	ev.xclient.data.l[2] = data2;
+	ev.xclient.data.l[3] = data3;
+	ev.xclient.data.l[4] = data4;
+
+	XSendEvent(dpy, win, False, 0, &ev);
+	XFlush(dpy);
+
+#ifdef XDND_DEBUG
+	printf("sent\n");
+#endif
+	return True;		/* message sent */
+}
+
+static void handleLeaveMessage(WMDraggingInfo * info)
+{
+	if (XDND_DEST_INFO(info) != NULL) {
+		/* XDND_DEST_VIEW is never NULL (it's the xdnd aware view) */
+		wassertr(XDND_DEST_VIEW(info) != NULL);
+		if (XDND_DEST_VIEW(info)->dragDestinationProcs != NULL) {
+			XDND_DEST_VIEW(info)->dragDestinationProcs->concludeDragOperation(XDND_DEST_VIEW(info));
+		}
+		W_DragDestinationInfoClear(info);
+	}
+}
+
+void W_HandleDNDClientMessage(WMView * toplevel, XClientMessageEvent * event)
+{
+	WMScreen *scr = W_VIEW_SCREEN(toplevel);
+	WMDraggingInfo *info = &scr->dragInfo;
+	Atom messageType = event->message_type;
+
+#ifdef XDND_DEBUG
+	{
+		char *msgTypeName = XGetAtomName(scr->display, messageType);
+
+		if (msgTypeName != NULL)
+			printf("event type = %s\n", msgTypeName);
+		else
+			printf("pb with event type !\n");
+	}
+#endif
+
+	/* Messages from destination to source */
+	if (messageType == scr->xdndStatusAtom || messageType == scr->xdndFinishedAtom) {
+		W_DragSourceStopTimer();
+		W_DragSourceStateHandler(info, event);
+		return;
+	}
+
+	/* Messages from source to destination */
+	if (messageType == scr->xdndEnterAtom) {
+		Bool positionSent = (XDND_DEST_INFO(info) != NULL);
+
+		W_DragDestinationStopTimer();
+		W_DragDestinationStoreEnterMsgInfo(info, toplevel, event);
+
+		/* Xdnd version 3 and up are not compatible with version 1 or 2 */
+		if (XDND_SOURCE_VERSION(info) > 2) {
+
+			if (positionSent) {
+				/* xdndPosition previously received on xdnd aware view */
+				W_DragDestinationStateHandler(info, event);
+				return;
+			} else {
+				W_DragDestinationStartTimer(info);
+				return;
+			}
+		} else {
+			wwarning(_("unsupported version %i for XDND enter message"), XDND_SOURCE_VERSION(info));
+			W_DragDestinationCancelDropOnEnter(toplevel, info);
+			return;
+		}
+	}
+
+	if (messageType == scr->xdndPositionAtom) {
+		W_DragDestinationStopTimer();
+		W_DragDestinationStorePositionMsgInfo(info, toplevel, event);
+		W_DragDestinationStateHandler(info, event);
+		return;
+	}
+
+	if (messageType == scr->xdndSelectionAtom || messageType == scr->xdndDropAtom) {
+		W_DragDestinationStopTimer();
+		W_DragDestinationStateHandler(info, event);
+		return;
+	}
+
+	if (messageType == scr->xdndLeaveAtom) {
+		/* conclude drop operation, and clear dragging info */
+		W_DragDestinationStopTimer();
+		handleLeaveMessage(info);
+	}
+}
+
+/* called in destroyView (wview.c) */
+void W_FreeViewXdndPart(WMView * view)
+{
+	WMUnregisterViewDraggedTypes(view);
+
+	if (view->dragSourceProcs)
+		wfree(view->dragSourceProcs);
+
+	if (view->dragDestinationProcs)
+		wfree(view->dragDestinationProcs);
+
+	if (view->dragImage)
+		WMReleasePixmap(view->dragImage);
+}

bazel/WINGs/dragdestination.c

@@ -0,0 +1,999 @@
+
+#include "WINGs/WINGsP.h"
+#include <X11/Xatom.h>
+
+#define XDND_SOURCE_RESPONSE_MAX_DELAY 3000
+
+#define XDND_PROPERTY_FORMAT 32
+#define XDND_ACTION_DESCRIPTION_FORMAT 8
+
+#define XDND_SOURCE_VERSION(dragInfo) dragInfo->protocolVersion
+#define XDND_DEST_INFO(dragInfo) dragInfo->destInfo
+#define XDND_AWARE_VIEW(dragInfo) dragInfo->destInfo->xdndAwareView
+#define XDND_SOURCE_WIN(dragInfo) dragInfo->destInfo->sourceWindow
+#define XDND_DEST_VIEW(dragInfo) dragInfo->destInfo->destView
+#define XDND_DEST_STATE(dragInfo) dragInfo->destInfo->state
+#define XDND_SOURCE_ACTION_CHANGED(dragInfo) dragInfo->destInfo->sourceActionChanged
+#define XDND_SOURCE_TYPES(dragInfo) dragInfo->destInfo->sourceTypes
+#define XDND_TYPE_LIST_AVAILABLE(dragInfo) dragInfo->destInfo->typeListAvailable
+#define XDND_REQUIRED_TYPES(dragInfo) dragInfo->destInfo->requiredTypes
+#define XDND_SOURCE_ACTION(dragInfo) dragInfo->sourceAction
+#define XDND_DEST_ACTION(dragInfo) dragInfo->destinationAction
+#define XDND_DROP_DATAS(dragInfo) dragInfo->destInfo->dropDatas
+#define XDND_DEST_VIEW_IS_REGISTERED(dragInfo) ((dragInfo->destInfo) != NULL)\
+    && ((dragInfo->destInfo->destView->dragDestinationProcs) != NULL)
+
+static const unsigned char XDNDversion = XDND_VERSION;
+static WMHandlerID dndDestinationTimer = NULL;
+
+static void *idleState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
+static void *waitEnterState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
+static void *inspectDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
+static void *dropAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
+static void *dropNotAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
+static void *waitForDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
+
+/* ----- Types & datas list ----- */
+static void freeSourceTypeArrayItem(void *type)
+{
+	XFree(type);
+}
+
+static WMArray *createSourceTypeArray(int initialSize)
+{
+	return WMCreateArrayWithDestructor(initialSize, freeSourceTypeArrayItem);
+}
+
+static void freeDropDataArrayItem(void *data)
+{
+	if (data != NULL)
+		WMReleaseData((WMData *) data);
+}
+
+static WMArray *createDropDataArray(WMArray * requiredTypes)
+{
+	if (requiredTypes != NULL)
+		return WMCreateArrayWithDestructor(WMGetArrayItemCount(requiredTypes), freeDropDataArrayItem);
+
+	else
+		return WMCreateArray(0);
+}
+
+static WMArray *getTypesFromTypeList(WMScreen * scr, Window sourceWin)
+{
+	Atom dataType;
+	Atom *typeAtomList;
+	WMArray *typeList;
+	int i, format;
+	unsigned long count, remaining;
+	unsigned char *data = NULL;
+
+	XGetWindowProperty(scr->display, sourceWin, scr->xdndTypeListAtom,
+			   0, 0x8000000L, False, XA_ATOM, &dataType, &format, &count, &remaining, &data);
+
+	if (dataType != XA_ATOM || format != XDND_PROPERTY_FORMAT || count == 0 || !data) {
+		if (data) {
+			XFree(data);
+		}
+		return createSourceTypeArray(0);
+	}
+
+	typeList = createSourceTypeArray(count);
+	typeAtomList = (Atom *) data;
+	for (i = 0; i < count; i++) {
+		WMAddToArray(typeList, XGetAtomName(scr->display, typeAtomList[i]));
+	}
+
+	XFree(data);
+
+	return typeList;
+}
+
+static WMArray *getTypesFromThreeTypes(WMScreen * scr, XClientMessageEvent * event)
+{
+	WMArray *typeList;
+	Atom atom;
+	int i;
+
+	typeList = createSourceTypeArray(3);
+	for (i = 2; i < 5; i++) {
+		if (event->data.l[i] != None) {
+			atom = (Atom) event->data.l[i];
+			WMAddToArray(typeList, XGetAtomName(scr->display, atom));
+		}
+	}
+
+	return typeList;
+}
+
+static void storeRequiredTypeList(WMDraggingInfo * info)
+{
+	WMView *destView = XDND_DEST_VIEW(info);
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+	WMArray *requiredTypes;
+
+	/* First, see if the stored source types are enough for dest requirements */
+	requiredTypes = destView->dragDestinationProcs->requiredDataTypes(destView,
+									  W_ActionToOperation(scr,
+											      XDND_SOURCE_ACTION
+											      (info)),
+									  XDND_SOURCE_TYPES(info));
+
+	if (requiredTypes == NULL && XDND_TYPE_LIST_AVAILABLE(info)) {
+		/* None of the stored source types fits, but the whole type list
+		   hasn't been retrieved yet. */
+		WMFreeArray(XDND_SOURCE_TYPES(info));
+		XDND_SOURCE_TYPES(info) = getTypesFromTypeList(scr, XDND_SOURCE_WIN(info));
+		/* Don't retrieve the type list again */
+		XDND_TYPE_LIST_AVAILABLE(info) = False;
+
+		requiredTypes =
+		    destView->dragDestinationProcs->requiredDataTypes(destView,
+								      W_ActionToOperation(scr,
+											  XDND_SOURCE_ACTION
+											  (info)),
+								      XDND_SOURCE_TYPES(info));
+	}
+
+	XDND_REQUIRED_TYPES(info) = requiredTypes;
+}
+
+static char *getNextRequestedDataType(WMDraggingInfo * info)
+{
+	/* get the type of the first data not yet retrieved from selection */
+	int nextTypeIndex;
+
+	if (XDND_REQUIRED_TYPES(info) != NULL) {
+		nextTypeIndex = WMGetArrayItemCount(XDND_DROP_DATAS(info));
+		return WMGetFromArray(XDND_REQUIRED_TYPES(info), nextTypeIndex);
+		/* NULL if no more type */
+	} else
+		return NULL;
+}
+
+/* ----- Action list ----- */
+
+static WMArray *sourceOperationList(WMScreen * scr, Window sourceWin)
+{
+	Atom dataType, *actionList;
+	int i, size;
+	unsigned long count, remaining;
+	unsigned char *actionDatas = NULL;
+	unsigned char *descriptionList = NULL;
+	WMArray *operationArray;
+	WMDragOperationItem *operationItem;
+	char *description;
+
+	remaining = 0;
+	XGetWindowProperty(scr->display, sourceWin, scr->xdndActionListAtom,
+			   0, 0x8000000L, False, XA_ATOM, &dataType, &size, &count, &remaining, &actionDatas);
+
+	if (dataType != XA_ATOM || size != XDND_PROPERTY_FORMAT || count == 0 || !actionDatas) {
+		wwarning("Cannot read action list");
+		if (actionDatas) {
+			XFree(actionDatas);
+		}
+		return NULL;
+	}
+
+	actionList = (Atom *) actionDatas;
+
+	XGetWindowProperty(scr->display, sourceWin, scr->xdndActionDescriptionAtom,
+			   0, 0x8000000L, False, XA_STRING, &dataType, &size,
+			   &count, &remaining, &descriptionList);
+
+	if (dataType != XA_STRING || size != XDND_ACTION_DESCRIPTION_FORMAT || count == 0 || !descriptionList) {
+		wwarning("Cannot read action description list");
+		if (actionList) {
+			XFree(actionList);
+		}
+		if (descriptionList) {
+			XFree(descriptionList);
+		}
+		return NULL;
+	}
+
+	operationArray = WMCreateDragOperationArray(count);
+	description = (char *)descriptionList;
+
+	for (i = 0; count > 0; i++) {
+		size = strlen(description);
+		operationItem = WMCreateDragOperationItem(W_ActionToOperation(scr, actionList[i]),
+							  wstrdup(description));
+
+		WMAddToArray(operationArray, operationItem);
+		count -= (size + 1);	/* -1 : -NULL char */
+
+		/* next description */
+		description = &(description[size + 1]);
+	}
+
+	XFree(actionList);
+	XFree(descriptionList);
+
+	return operationArray;
+}
+
+/* ----- Dragging Info ----- */
+static void updateSourceWindow(WMDraggingInfo * info, XClientMessageEvent * event)
+{
+	XDND_SOURCE_WIN(info) = (Window) event->data.l[0];
+}
+
+static WMView *findChildInView(WMView * parent, int x, int y)
+{
+	if (parent->childrenList == NULL)
+		return parent;
+	else {
+		WMView *child = parent->childrenList;
+
+		while (child != NULL
+		       && (!child->flags.mapped
+			   || x < WMGetViewPosition(child).x
+			   || x > WMGetViewPosition(child).x + WMGetViewSize(child).width
+			   || y < WMGetViewPosition(child).y
+			   || y > WMGetViewPosition(child).y + WMGetViewSize(child).height))
+
+			child = child->nextSister;
+
+		if (child == NULL)
+			return parent;
+		else
+			return findChildInView(child,
+					       x - WMGetViewPosition(child).x, y - WMGetViewPosition(child).y);
+	}
+}
+
+static WMView *findDestinationViewInToplevel(WMView * toplevel, int x, int y)
+{
+	WMScreen *scr = W_VIEW_SCREEN(toplevel);
+	Window toplevelWin = WMViewXID(toplevel);
+	int xInToplevel, yInToplevel;
+	Window foo;
+
+	XTranslateCoordinates(scr->display, scr->rootWin, toplevelWin, x, y, &xInToplevel, &yInToplevel, &foo);
+	return findChildInView(toplevel, xInToplevel, yInToplevel);
+}
+
+/* Clear datas only used by current destination view */
+static void freeDestinationViewInfos(WMDraggingInfo * info)
+{
+	if (XDND_SOURCE_TYPES(info) != NULL) {
+		WMFreeArray(XDND_SOURCE_TYPES(info));
+		XDND_SOURCE_TYPES(info) = NULL;
+	}
+
+	if (XDND_DROP_DATAS(info) != NULL) {
+		WMFreeArray(XDND_DROP_DATAS(info));
+		XDND_DROP_DATAS(info) = NULL;
+	}
+
+	XDND_REQUIRED_TYPES(info) = NULL;
+}
+
+void W_DragDestinationInfoClear(WMDraggingInfo * info)
+{
+	W_DragDestinationStopTimer();
+
+	if (XDND_DEST_INFO(info) != NULL) {
+		freeDestinationViewInfos(info);
+
+		wfree(XDND_DEST_INFO(info));
+		XDND_DEST_INFO(info) = NULL;
+	}
+}
+
+static void initDestinationDragInfo(WMDraggingInfo * info, WMView * destView)
+{
+	wassertr(destView != NULL);
+
+	XDND_DEST_INFO(info) = (W_DragDestinationInfo *) wmalloc(sizeof(W_DragDestinationInfo));
+
+	XDND_DEST_STATE(info) = idleState;
+	XDND_DEST_VIEW(info) = destView;
+
+	XDND_SOURCE_ACTION_CHANGED(info) = False;
+	XDND_SOURCE_TYPES(info) = NULL;
+	XDND_REQUIRED_TYPES(info) = NULL;
+	XDND_DROP_DATAS(info) = NULL;
+}
+
+void W_DragDestinationStoreEnterMsgInfo(WMDraggingInfo * info, WMView * toplevel, XClientMessageEvent * event)
+{
+	WMScreen *scr = W_VIEW_SCREEN(toplevel);
+
+	if (XDND_DEST_INFO(info) == NULL)
+		initDestinationDragInfo(info, toplevel);
+
+	XDND_SOURCE_VERSION(info) = (event->data.l[1] >> 24);
+	XDND_AWARE_VIEW(info) = toplevel;
+	updateSourceWindow(info, event);
+
+#if 0
+    if (event->data.l[1] & 1)
+        /* XdndTypeList property is available */
+        XDND_SOURCE_TYPES(info) = getTypesFromTypeList(scr, XDND_SOURCE_WIN(info));
+    else
+        XDND_SOURCE_TYPES(info) = getTypesFromThreeTypes(scr, event);
+#endif
+	XDND_SOURCE_TYPES(info) = getTypesFromThreeTypes(scr, event);
+
+	/* to use if the 3 types are not enough */
+	XDND_TYPE_LIST_AVAILABLE(info) = (event->data.l[1] & 1);
+}
+
+void W_DragDestinationStorePositionMsgInfo(WMDraggingInfo * info, WMView * toplevel, XClientMessageEvent * event)
+{
+	int x = event->data.l[2] >> 16;
+	int y = event->data.l[2] & 0xffff;
+	WMView *newDestView;
+
+	newDestView = findDestinationViewInToplevel(toplevel, x, y);
+
+	if (XDND_DEST_INFO(info) == NULL) {
+		initDestinationDragInfo(info, newDestView);
+		XDND_AWARE_VIEW(info) = toplevel;
+		updateSourceWindow(info, event);
+	} else {
+		if (newDestView != XDND_DEST_VIEW(info)) {
+			updateSourceWindow(info, event);
+			XDND_DEST_VIEW(info) = newDestView;
+			XDND_SOURCE_ACTION_CHANGED(info) = False;
+
+			if (XDND_DEST_STATE(info) != waitEnterState)
+				XDND_DEST_STATE(info) = idleState;
+		} else {
+			XDND_SOURCE_ACTION_CHANGED(info) = (XDND_SOURCE_ACTION(info) != event->data.l[4]);
+		}
+	}
+
+	XDND_SOURCE_ACTION(info) = event->data.l[4];
+
+	/* note: source position is not stored */
+}
+
+/* ----- End of Dragging Info ----- */
+
+/* ----- Messages ----- */
+
+/* send a DnD message to the source window */
+static void
+sendDnDClientMessage(WMDraggingInfo * info, Atom message,
+		     unsigned long data1, unsigned long data2, unsigned long data3, unsigned long data4)
+{
+	if (!W_SendDnDClientMessage(W_VIEW_SCREEN(XDND_AWARE_VIEW(info))->display,
+				    XDND_SOURCE_WIN(info),
+				    message, WMViewXID(XDND_AWARE_VIEW(info)), data1, data2, data3, data4)) {
+		/* drop failed */
+		W_DragDestinationInfoClear(info);
+	}
+}
+
+/* send a xdndStatus message to the source, with position and size
+   of the destination if it has no subwidget (requesting a position message
+   on every move otherwise) */
+static void sendStatusMessage(WMView * destView, WMDraggingInfo * info, Atom action)
+{
+	unsigned long data1;
+
+	data1 = (action == None) ? 0 : 1;
+
+	if (destView->childrenList == NULL) {
+		WMScreen *scr = W_VIEW_SCREEN(destView);
+		int destX, destY;
+		WMSize destSize = WMGetViewSize(destView);
+		Window foo;
+
+		XTranslateCoordinates(scr->display, WMViewXID(destView), scr->rootWin, 0, 0, &destX, &destY, &foo);
+
+		sendDnDClientMessage(info,
+				     W_VIEW_SCREEN(destView)->xdndStatusAtom,
+				     data1,
+				     (destX << 16) | destY, (destSize.width << 16) | destSize.height, action);
+	} else {
+		/* set bit 1 to request explicitly position message on every move */
+		data1 = data1 | 2;
+
+		sendDnDClientMessage(info, W_VIEW_SCREEN(destView)->xdndStatusAtom, data1, 0, 0, action);
+	}
+}
+
+static void
+storeDropData(WMView * destView, Atom selection, Atom target, Time timestamp, void *cdata, WMData * data)
+{
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+	WMDraggingInfo *info = &(scr->dragInfo);
+	WMData *dataToStore = NULL;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) selection;
+	(void) target;
+	(void) timestamp;
+	(void) cdata;
+
+	if (data != NULL)
+		dataToStore = WMRetainData(data);
+
+	if (XDND_DEST_INFO(info) != NULL && XDND_DROP_DATAS(info) != NULL) {
+		WMAddToArray(XDND_DROP_DATAS(info), dataToStore);
+		W_SendDnDClientMessage(scr->display, WMViewXID(destView),
+				       scr->xdndSelectionAtom, WMViewXID(destView), 0, 0, 0, 0);
+	}
+}
+
+static Bool requestDropDataInSelection(WMView * destView, const char *type)
+{
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+
+	if (type != NULL) {
+		if (!WMRequestSelection(destView,
+					scr->xdndSelectionAtom,
+					XInternAtom(scr->display, type, False),
+					CurrentTime, storeDropData, NULL)) {
+			wwarning("could not request data for dropped data");
+			return False;
+		}
+
+		return True;
+	}
+
+	return False;
+}
+
+static Bool requestDropData(WMDraggingInfo * info)
+{
+	WMView *destView = XDND_DEST_VIEW(info);
+	char *nextType = getNextRequestedDataType(info);
+
+	while ((nextType != NULL)
+	       && (!requestDropDataInSelection(destView, nextType))) {
+		/* store NULL if request failed, and try with next type */
+		WMAddToArray(XDND_DROP_DATAS(info), NULL);
+		nextType = getNextRequestedDataType(info);
+	}
+
+	/* remains types to retrieve ? */
+	return (nextType != NULL);
+}
+
+static void concludeDrop(WMView * destView)
+{
+	destView->dragDestinationProcs->concludeDragOperation(destView);
+}
+
+/* send cancel message to the source */
+static void cancelDrop(WMView * destView, WMDraggingInfo * info)
+{
+	sendStatusMessage(destView, info, None);
+	concludeDrop(destView);
+	freeDestinationViewInfos(info);
+}
+
+/* suspend drop, when dragged icon enter an unregistered view
+   or a register view that doesn't accept the drop */
+static void suspendDropAuthorization(WMView * destView, WMDraggingInfo * info)
+{
+	sendStatusMessage(destView, info, None);
+
+	/* Free datas that depend on destination behaviour */
+	if (XDND_DROP_DATAS(info) != NULL) {
+		WMFreeArray(XDND_DROP_DATAS(info));
+		XDND_DROP_DATAS(info) = NULL;
+	}
+
+	XDND_REQUIRED_TYPES(info) = NULL;
+}
+
+/* cancel drop on Enter message, if protocol version is nok */
+void W_DragDestinationCancelDropOnEnter(WMView * toplevel, WMDraggingInfo * info)
+{
+	if (XDND_DEST_VIEW_IS_REGISTERED(info))
+		cancelDrop(XDND_DEST_VIEW(info), info);
+	else
+		sendStatusMessage(toplevel, info, None);
+
+	W_DragDestinationInfoClear(info);
+}
+
+static void finishDrop(WMView * destView, WMDraggingInfo * info)
+{
+	sendDnDClientMessage(info, W_VIEW_SCREEN(destView)->xdndFinishedAtom, 0, 0, 0, 0);
+	concludeDrop(destView);
+	W_DragDestinationInfoClear(info);
+}
+
+static Atom getAllowedAction(WMView * destView, WMDraggingInfo * info)
+{
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+
+	return W_OperationToAction(scr,
+				   destView->dragDestinationProcs->allowedOperation(destView,
+										    W_ActionToOperation(scr,
+													XDND_SOURCE_ACTION
+													(info)),
+										    XDND_SOURCE_TYPES(info)));
+}
+
+static void *checkActionAllowed(WMView * destView, WMDraggingInfo * info)
+{
+	XDND_DEST_ACTION(info) = getAllowedAction(destView, info);
+
+	if (XDND_DEST_ACTION(info) == None) {
+		suspendDropAuthorization(destView, info);
+		return dropNotAllowedState;
+	}
+
+	sendStatusMessage(destView, info, XDND_DEST_ACTION(info));
+	return dropAllowedState;
+}
+
+static void *checkDropAllowed(WMView *destView, WMDraggingInfo *info)
+{
+	storeRequiredTypeList(info);
+
+	if (destView->dragDestinationProcs->inspectDropData != NULL) {
+		XDND_DROP_DATAS(info) = createDropDataArray(XDND_REQUIRED_TYPES(info));
+
+		/* store first available data */
+		if (requestDropData(info))
+			return inspectDropDataState;
+
+		/* no data retrieved, but inspect can allow it */
+		if (destView->dragDestinationProcs->inspectDropData(destView, XDND_DROP_DATAS(info)))
+			return checkActionAllowed(destView, info);
+
+		suspendDropAuthorization(destView, info);
+		return dropNotAllowedState;
+	}
+
+	return checkActionAllowed(destView, info);
+}
+
+static WMPoint *getDropLocationInView(WMView * view)
+{
+	Window rootWin, childWin;
+	int rootX, rootY;
+	unsigned int mask;
+	WMPoint *location;
+
+	location = (WMPoint *) wmalloc(sizeof(WMPoint));
+
+	XQueryPointer(W_VIEW_SCREEN(view)->display,
+		      WMViewXID(view), &rootWin, &childWin, &rootX, &rootY, &(location->x), &(location->y), &mask);
+
+	return location;
+}
+
+static void callPerformDragOperation(WMView * destView, WMDraggingInfo * info)
+{
+	WMArray *operationList = NULL;
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+	WMPoint *dropLocation;
+
+	if (XDND_SOURCE_ACTION(info) == scr->xdndActionAsk)
+		operationList = sourceOperationList(scr, XDND_SOURCE_WIN(info));
+
+	dropLocation = getDropLocationInView(destView);
+	destView->dragDestinationProcs->performDragOperation(destView,
+							     XDND_DROP_DATAS(info), operationList, dropLocation);
+
+	wfree(dropLocation);
+	if (operationList != NULL)
+		WMFreeArray(operationList);
+}
+
+/* ----- Destination timer ----- */
+static void dragSourceResponseTimeOut(void *destView)
+{
+	WMView *view = (WMView *) destView;
+	WMDraggingInfo *info;
+
+	wwarning("delay for drag source response expired");
+	info = &(W_VIEW_SCREEN(view)->dragInfo);
+	if (XDND_DEST_VIEW_IS_REGISTERED(info))
+		cancelDrop(view, info);
+	else {
+		sendStatusMessage(view, info, None);
+	}
+
+	W_DragDestinationInfoClear(info);
+}
+
+void W_DragDestinationStopTimer(void)
+{
+	if (dndDestinationTimer != NULL) {
+		WMDeleteTimerHandler(dndDestinationTimer);
+		dndDestinationTimer = NULL;
+	}
+}
+
+void W_DragDestinationStartTimer(WMDraggingInfo * info)
+{
+	W_DragDestinationStopTimer();
+
+	if (XDND_DEST_STATE(info) != idleState)
+		dndDestinationTimer = WMAddTimerHandler(XDND_SOURCE_RESPONSE_MAX_DELAY,
+							dragSourceResponseTimeOut, XDND_DEST_VIEW(info));
+}
+
+/* ----- End of Destination timer ----- */
+
+/* ----- Destination states ----- */
+
+#ifdef XDND_DEBUG
+static const char *stateName(W_DndState * state)
+{
+	if (state == NULL)
+		return "no state defined";
+
+	if (state == idleState)
+		return "idleState";
+
+	if (state == waitEnterState)
+		return "waitEnterState";
+
+	if (state == inspectDropDataState)
+		return "inspectDropDataState";
+
+	if (state == dropAllowedState)
+		return "dropAllowedState";
+
+	if (state == dropNotAllowedState)
+		return "dropNotAllowedState";
+
+	if (state == waitForDropDataState)
+		return "waitForDropDataState";
+
+	return "unknown state";
+}
+#endif
+
+static void *idleState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
+{
+	WMScreen *scr;
+	Atom sourceMsg;
+
+	if (destView->dragDestinationProcs != NULL) {
+		scr = W_VIEW_SCREEN(destView);
+		sourceMsg = event->message_type;
+
+		if (sourceMsg == scr->xdndPositionAtom) {
+			destView->dragDestinationProcs->prepareForDragOperation(destView);
+
+			if (XDND_SOURCE_TYPES(info) != NULL) {
+				/* enter message infos are available */
+				return checkDropAllowed(destView, info);
+			}
+
+			/* waiting for enter message */
+			return waitEnterState;
+		}
+	}
+
+	suspendDropAuthorization(destView, info);
+	return idleState;
+}
+
+/*  Source position and action are stored,
+ waiting for xdnd protocol version and source type */
+static void *waitEnterState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
+{
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+	Atom sourceMsg = event->message_type;
+
+	if (sourceMsg == scr->xdndEnterAtom) {
+		W_DragDestinationStoreEnterMsgInfo(info, destView, event);
+		return checkDropAllowed(destView, info);
+	}
+
+	return waitEnterState;
+}
+
+/* We have requested a data, and have received it */
+static void *inspectDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
+{
+	WMScreen *scr;
+	Atom sourceMsg;
+
+	scr = W_VIEW_SCREEN(destView);
+	sourceMsg = event->message_type;
+
+	if (sourceMsg == scr->xdndSelectionAtom) {
+		/* a data has been retrieved, store next available */
+		if (requestDropData(info))
+			return inspectDropDataState;
+
+		/* all required (and available) datas are stored */
+		if (destView->dragDestinationProcs->inspectDropData(destView, XDND_DROP_DATAS(info)))
+			return checkActionAllowed(destView, info);
+
+		suspendDropAuthorization(destView, info);
+		return dropNotAllowedState;
+	}
+
+	return inspectDropDataState;
+}
+
+static void *dropNotAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
+{
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+	Atom sourceMsg = event->message_type;
+
+	if (sourceMsg == scr->xdndDropAtom) {
+		finishDrop(destView, info);
+		return idleState;
+	}
+
+	if (sourceMsg == scr->xdndPositionAtom) {
+		if (XDND_SOURCE_ACTION_CHANGED(info)) {
+			return checkDropAllowed(destView, info);
+		} else {
+			sendStatusMessage(destView, info, None);
+			return dropNotAllowedState;
+		}
+	}
+
+	return dropNotAllowedState;
+}
+
+static void *dropAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
+{
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+	Atom sourceMsg = event->message_type;
+
+	if (sourceMsg == scr->xdndDropAtom) {
+		if (XDND_DROP_DATAS(info) != NULL) {
+			/* drop datas were cached with inspectDropData call */
+			callPerformDragOperation(destView, info);
+		} else {
+			XDND_DROP_DATAS(info) = createDropDataArray(XDND_REQUIRED_TYPES(info));
+
+			/* store first available data */
+			if (requestDropData(info))
+				return waitForDropDataState;
+
+			/* no data retrieved */
+			callPerformDragOperation(destView, info);
+		}
+
+		finishDrop(destView, info);
+		return idleState;
+	}
+
+	if (sourceMsg == scr->xdndPositionAtom) {
+		if (XDND_SOURCE_ACTION_CHANGED(info)) {
+			return checkDropAllowed(destView, info);
+		} else {
+			sendStatusMessage(destView, info, XDND_DEST_ACTION(info));
+			return dropAllowedState;
+		}
+	}
+
+	return dropAllowedState;
+}
+
+static void *waitForDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
+{
+	WMScreen *scr = W_VIEW_SCREEN(destView);
+	Atom sourceMsg = event->message_type;
+
+	if (sourceMsg == scr->xdndSelectionAtom) {
+		/* store next data */
+		if (requestDropData(info))
+			return waitForDropDataState;
+
+		/* all required (and available) datas are stored */
+		callPerformDragOperation(destView, info);
+
+		finishDrop(destView, info);
+		return idleState;
+	}
+
+	return waitForDropDataState;
+}
+
+/* ----- End of Destination states ----- */
+
+void W_DragDestinationStateHandler(WMDraggingInfo * info, XClientMessageEvent * event)
+{
+	WMView *destView;
+	W_DndState *newState;
+
+	wassertr(XDND_DEST_INFO(info) != NULL);
+	wassertr(XDND_DEST_VIEW(info) != NULL);
+
+	destView = XDND_DEST_VIEW(info);
+	if (XDND_DEST_STATE(info) == NULL)
+		XDND_DEST_STATE(info) = idleState;
+
+#ifdef XDND_DEBUG
+
+	printf("current dest state: %s\n", stateName(XDND_DEST_STATE(info)));
+#endif
+
+	newState = (W_DndState *) XDND_DEST_STATE(info) (destView, event, info);
+
+#ifdef XDND_DEBUG
+
+	printf("new dest state: %s\n", stateName(newState));
+#endif
+
+	if (XDND_DEST_INFO(info) != NULL) {
+		XDND_DEST_STATE(info) = newState;
+		if (XDND_DEST_STATE(info) != idleState)
+			W_DragDestinationStartTimer(info);
+	}
+}
+
+static void realizedObserver(void *self, WMNotification * notif)
+{
+	WMView *view = (WMView *) WMGetNotificationObject(notif);
+	WMScreen *scr = W_VIEW_SCREEN(view);
+
+	XChangeProperty(scr->display, W_VIEW_DRAWABLE(view),
+			scr->xdndAwareAtom, XA_ATOM, XDND_PROPERTY_FORMAT, PropModeReplace, &XDNDversion, 1);
+
+	WMRemoveNotificationObserver(self);
+}
+
+static void W_SetXdndAwareProperty(WMScreen *scr, WMView *view)
+{
+	WMView *toplevel = W_TopLevelOfView(view);
+
+	if (!toplevel->flags.xdndHintSet) {
+		toplevel->flags.xdndHintSet = 1;
+
+		if (toplevel->flags.realized) {
+			XChangeProperty(scr->display, W_VIEW_DRAWABLE(toplevel),
+					scr->xdndAwareAtom, XA_ATOM, XDND_PROPERTY_FORMAT,
+					PropModeReplace, &XDNDversion, 1);
+		} else {
+			WMAddNotificationObserver(realizedObserver,
+						  /* just use as an id */
+						  &view->dragDestinationProcs,
+						  WMViewRealizedNotification, toplevel);
+		}
+	}
+}
+
+void WMRegisterViewForDraggedTypes(WMView * view, WMArray * acceptedTypes)
+{
+	Atom *types;
+	int typeCount;
+	int i;
+
+	typeCount = WMGetArrayItemCount(acceptedTypes);
+	types = wmalloc(sizeof(Atom) * (typeCount + 1));
+
+	for (i = 0; i < typeCount; i++) {
+		types[i] = XInternAtom(W_VIEW_SCREEN(view)->display, WMGetFromArray(acceptedTypes, i), False);
+	}
+	types[i] = 0;
+
+	view->droppableTypes = types;
+	/* WMFreeArray(acceptedTypes); */
+
+	W_SetXdndAwareProperty(W_VIEW_SCREEN(view), view);
+}
+
+void WMUnregisterViewDraggedTypes(WMView * view)
+{
+	if (view->droppableTypes != NULL)
+		wfree(view->droppableTypes);
+	view->droppableTypes = NULL;
+}
+
+/*
+ requestedOperation: operation requested by the source
+ sourceDataTypes:  data types (mime-types strings) supported by the source
+ (never NULL, destroyed when drop ends)
+ return operation allowed by destination (self)
+ */
+static WMDragOperationType
+defAllowedOperation(WMView * self, WMDragOperationType requestedOperation, WMArray * sourceDataTypes)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+	(void) requestedOperation;
+	(void) sourceDataTypes;
+
+	/* no operation allowed */
+	return WDOperationNone;
+}
+
+/*
+ requestedOperation: operation requested by the source
+ sourceDataTypes:  data types (mime-types strings) supported by the source
+ (never NULL, destroyed when drop ends)
+ return data types (mime-types strings) required by destination (self)
+ or NULL if no suitable data type is available (force
+ to 2nd pass with full source type list).
+ */
+static WMArray *defRequiredDataTypes(WMView * self,
+				     WMDragOperationType requestedOperation, WMArray * sourceDataTypes)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+	(void) requestedOperation;
+	(void) sourceDataTypes;
+
+	/* no data type allowed (NULL even at 2nd pass) */
+	return NULL;
+}
+
+/*
+ Executed when the drag enters destination (self)
+ */
+static void defPrepareForDragOperation(WMView * self)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+}
+
+/*
+ Checks datas to be dropped (optional).
+ dropDatas: datas (WMData*) required by destination (self)
+ (given in same order as returned by requiredDataTypes).
+ A NULL data means it couldn't be retreived.
+ Destroyed when drop ends.
+ return true if data array is ok
+ */
+/* Bool (*inspectDropData)(WMView *self, WMArray *dropDatas); */
+
+/*
+ Process drop
+ dropDatas: datas (WMData*) required by destination (self)
+ (given in same order as returned by requiredDataTypes).
+ A NULL data means it couldn't be retrieved.
+ Destroyed when drop ends.
+ operationList: if source operation is WDOperationAsk, contains
+ operations (and associated texts) that can be asked
+ to source. (destroyed after performDragOperation call)
+ Otherwise this parameter is NULL.
+ */
+static void
+defPerformDragOperation(WMView * self, WMArray * dropDatas, WMArray * operationList, WMPoint * dropLocation)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+	(void) dropDatas;
+	(void) operationList;
+	(void) dropLocation;
+}
+
+/* Executed after drop */
+static void defConcludeDragOperation(WMView * self)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+}
+
+void WMSetViewDragDestinationProcs(WMView * view, WMDragDestinationProcs * procs)
+{
+	if (view->dragDestinationProcs == NULL) {
+		view->dragDestinationProcs = wmalloc(sizeof(WMDragDestinationProcs));
+	}
+
+	*view->dragDestinationProcs = *procs;
+
+	/*XXX fill in non-implemented stuffs */
+	if (procs->allowedOperation == NULL) {
+		view->dragDestinationProcs->allowedOperation = defAllowedOperation;
+	}
+	if (procs->allowedOperation == NULL) {
+		view->dragDestinationProcs->requiredDataTypes = defRequiredDataTypes;
+	}
+
+	/* note: inspectDropData can be NULL, if data consultation is not needed
+	   to give drop permission */
+
+	if (procs->prepareForDragOperation == NULL) {
+		view->dragDestinationProcs->prepareForDragOperation = defPrepareForDragOperation;
+	}
+	if (procs->performDragOperation == NULL) {
+		view->dragDestinationProcs->performDragOperation = defPerformDragOperation;
+	}
+	if (procs->concludeDragOperation == NULL) {
+		view->dragDestinationProcs->concludeDragOperation = defConcludeDragOperation;
+	}
+}

bazel/WINGs/error.c

@@ -0,0 +1,147 @@
+/*
+ *  Window Maker miscelaneous function library
+ *
+ *  Copyright (c) 1997-2003 Alfredo K. Kojima
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ *  MA 02110-1301, USA.
+ */
+
+#include "wconfig.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "WINGs/WUtil.h"
+#include "WINGs/WINGsP.h"
+
+#ifdef HAVE_SYSLOG_H
+#include <syslog.h>
+
+static Bool syslog_initialized = False;
+
+
+static void syslog_open(const char *prog_name)
+{
+	int options;
+
+	if (!prog_name)
+		prog_name = "WINGs";
+
+	options = LOG_PID;
+	openlog(prog_name, options, LOG_DAEMON);
+	syslog_initialized = True;
+}
+
+static void syslog_message(int prio, const char *prog_name, const char *msg)
+{
+	if (!syslog_initialized)
+		syslog_open(prog_name);
+
+	//jump over the program name cause syslog is already displaying it
+	syslog(prio, "%s", msg + strlen(prog_name));
+}
+
+void w_syslog_close(void)
+{
+	if (syslog_initialized) {
+		closelog();
+		syslog_initialized = False;
+	}
+}
+#endif
+
+void __wmessage(const char *func, const char *file, int line, int type, const char *msg, ...)
+{
+	va_list args;
+	char *buf;
+	static int linemax = 0;
+	int truncated = 0;
+#ifdef HAVE_SYSLOG
+	int syslog_priority = LOG_INFO;
+#endif
+
+	if (linemax == 0) {
+#ifdef HAVE_SYSCONF
+		linemax = sysconf(_SC_LINE_MAX);
+		if (linemax == -1) {
+			/* I'd like to know of this ever fires */
+			fprintf(stderr, "%s %d: sysconf(_SC_LINE_MAX) returned error\n",
+				__FILE__, __LINE__);
+			linemax = 512;
+		}
+#else /* !HAVE_SYSCONF */
+		fprintf(stderr, "%s %d: Your system does not have sysconf(3); "
+			"let wmaker-dev@windowmaker.org know.\n", __FILE__, __LINE__);
+		linemax = 512;
+#endif /* HAVE_SYSCONF */
+	}
+
+	buf = wmalloc(linemax);
+
+	fflush(stdout);
+
+	/* message format: <wings_progname>(function(file:line): <type?>: <message>"\n" */
+	strncat(buf, _WINGS_progname ? _WINGS_progname : "WINGs", linemax - 1);
+	snprintf(buf + strlen(buf), linemax - strlen(buf), "(%s(%s:%d))", func, file, line);
+	strncat(buf, ": ", linemax - 1 - strlen(buf));
+
+	switch (type) {
+		case WMESSAGE_TYPE_FATAL:
+			strncat(buf, _("fatal: "), linemax - 1 - strlen(buf));
+#ifdef HAVE_SYSLOG
+			syslog_priority = LOG_CRIT;
+#endif
+		break;
+		case WMESSAGE_TYPE_ERROR:
+			strncat(buf, _("error: "), linemax - 1 - strlen(buf));
+#ifdef HAVE_SYSLOG
+			syslog_priority = LOG_ERR;
+#endif
+		break;
+		case WMESSAGE_TYPE_WARNING:
+			strncat(buf, _("warning: "), linemax - 1 - strlen(buf));
+#ifdef HAVE_SYSLOG
+			syslog_priority = LOG_WARNING;
+#endif
+		break;
+		case WMESSAGE_TYPE_MESSAGE:
+			/* FALLTHROUGH */
+		default:	/* should not happen, but doesn't hurt either */
+		break;
+	}
+
+	va_start(args, msg);
+	if (vsnprintf(buf + strlen(buf), linemax - strlen(buf), msg, args) >= linemax - strlen(buf))
+		truncated = 1;
+
+	va_end(args);
+
+	fputs(buf, stderr);
+#ifdef HAVE_SYSLOG
+	syslog_message(syslog_priority, _WINGS_progname ? _WINGS_progname : "WINGs", buf);
+#endif
+
+	if (truncated)
+		fputs("*** message truncated ***", stderr);
+
+	fputs("\n", stderr);
+
+	wfree(buf);
+}
+

bazel/WINGs/error.h

@@ -0,0 +1,36 @@
+/* WUtil / error.h
+ *
+ *  Copyright (c) 2014 Window Maker Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef WUTIL_ERROR_H
+#define WUTIL_ERROR_H
+
+/*
+ * This file is not part of WUtil public API
+ *
+ * It defines internal things for the error message display functions
+ */
+
+
+#ifdef HAVE_SYSLOG_H
+/* Function to cleanly close the syslog stuff, called by wutil_shutdown from user side */
+void w_syslog_close(void);
+#endif
+
+
+#endif /* WUTIL_ERROR_H */

bazel/WINGs/findfile.c

@@ -0,0 +1,523 @@
+/*
+ *  Window Maker miscelaneous function library
+ *
+ *  Copyright (c) 1997-2003 Alfredo K. Kojima
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ *  MA 02110-1301, USA.
+ */
+
+#include "wconfig.h"
+
+#include "WUtil.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <pwd.h>
+#include <limits.h>
+
+#ifndef PATH_MAX
+#define PATH_MAX  1024
+#endif
+
+
+const char *wgethomedir(void)
+{
+	static char *home = NULL;
+	char *tmp;
+	struct passwd *user;
+
+	if (home)
+		return home;
+
+	tmp = GETENV("HOME");
+	if (tmp) {
+		home = wstrdup(tmp);
+		return home;
+	}
+
+	user = getpwuid(getuid());
+	if (!user) {
+		werror(_("could not get password entry for UID %i"), getuid());
+		home = "/";
+		return home;
+	}
+
+	if (!user->pw_dir)
+		home = "/";
+	else
+		home = wstrdup(user->pw_dir);
+
+	return home;
+}
+
+/*
+ * Return the home directory for the specified used
+ *
+ * If user not found, returns NULL, otherwise always returns a path that is
+ * statically stored.
+ *
+ * Please note you must use the path before any other call to 'getpw*' or it
+ * may be erased. This is a design choice to avoid duplication considering
+ * the use case for this function.
+ */
+static const char *getuserhomedir(const char *username)
+{
+	static const char default_home[] = "/";
+	struct passwd *user;
+
+	user = getpwnam(username);
+	if (!user) {
+		werror(_("could not get password entry for user %s"), username);
+		return NULL;
+	}
+	if (!user->pw_dir)
+		return default_home;
+	else
+		return user->pw_dir;
+
+}
+
+char *wexpandpath(const char *path)
+{
+	const char *origpath = path;
+	char buffer2[PATH_MAX + 2];
+	char buffer[PATH_MAX + 2];
+	int i;
+
+	memset(buffer, 0, PATH_MAX + 2);
+
+	if (*path == '~') {
+		const char *home;
+
+		path++;
+		if (*path == '/' || *path == 0) {
+			home = wgethomedir();
+			if (strlen(home) > PATH_MAX ||
+			    wstrlcpy(buffer, home, sizeof(buffer)) >= sizeof(buffer))
+				goto error;
+		} else {
+			int j;
+			j = 0;
+			while (*path != 0 && *path != '/') {
+				if (j > PATH_MAX)
+					goto error;
+				buffer2[j++] = *path;
+				buffer2[j] = 0;
+				path++;
+			}
+			home = getuserhomedir(buffer2);
+			if (!home || wstrlcat(buffer, home, sizeof(buffer)) >= sizeof(buffer))
+				goto error;
+		}
+	}
+
+	i = strlen(buffer);
+
+	while (*path != 0 && i <= PATH_MAX) {
+		char *tmp;
+
+		if (*path == '$') {
+			int j;
+
+			path++;
+			/* expand $(HOME) or $HOME style environment variables */
+			if (*path == '(') {
+				path++;
+				j = 0;
+				while (*path != 0 && *path != ')') {
+					if (j > PATH_MAX)
+						goto error;
+					buffer2[j++] = *(path++);
+				}
+				buffer2[j] = 0;
+				if (*path == ')') {
+					path++;
+					tmp = getenv(buffer2);
+				} else {
+					tmp = NULL;
+				}
+				if (!tmp) {
+					if ((i += strlen(buffer2) + 2) > PATH_MAX)
+						goto error;
+					buffer[i] = 0;
+					if (wstrlcat(buffer, "$(", sizeof(buffer)) >= sizeof(buffer) ||
+					    wstrlcat(buffer, buffer2, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+					if (*(path-1)==')') {
+						if (++i > PATH_MAX ||
+						    wstrlcat(buffer, ")", sizeof(buffer)) >= sizeof(buffer))
+							goto error;
+					}
+				} else {
+					if ((i += strlen(tmp)) > PATH_MAX ||
+					    wstrlcat(buffer, tmp, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+				}
+			} else {
+				j = 0;
+				while (*path != 0 && *path != '/') {
+					if (j > PATH_MAX)
+						goto error;
+					buffer2[j++] = *(path++);
+				}
+				buffer2[j] = 0;
+				tmp = getenv(buffer2);
+				if (!tmp) {
+					if ((i += strlen(buffer2) + 1) > PATH_MAX ||
+					    wstrlcat(buffer, "$", sizeof(buffer)) >= sizeof(buffer) ||
+					    wstrlcat(buffer, buffer2, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+				} else {
+					if ((i += strlen(tmp)) > PATH_MAX ||
+					    wstrlcat(buffer, tmp, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+				}
+			}
+		} else {
+			buffer[i++] = *path;
+			path++;
+		}
+	}
+
+	if (*path!=0)
+		goto error;
+
+	return wstrdup(buffer);
+
+error:
+	errno = ENAMETOOLONG;
+	werror(_("could not expand %s"), origpath);
+
+	return NULL;
+}
+
+/* return address of next char != tok or end of string whichever comes first */
+static const char *skipchar(const char *string, char tok)
+{
+	while (*string != 0 && *string == tok)
+		string++;
+
+	return string;
+}
+
+/* return address of next char == tok or end of string whichever comes first */
+static const char *nextchar(const char *string, char tok)
+{
+	while (*string != 0 && *string != tok)
+		string++;
+
+	return string;
+}
+
+/*
+ *----------------------------------------------------------------------
+ * findfile--
+ * 	Finds a file in a : separated list of paths. ~ expansion is also
+ * done.
+ *
+ * Returns:
+ * 	The complete path for the file (in a newly allocated string) or
+ * NULL if the file was not found.
+ *
+ * Side effects:
+ * 	A new string is allocated. It must be freed later.
+ *
+ *----------------------------------------------------------------------
+ */
+char *wfindfile(const char *paths, const char *file)
+{
+	char *path;
+	const char *tmp, *tmp2;
+	int len, flen;
+	char *fullpath;
+
+	if (!file)
+		return NULL;
+
+	if (*file == '/' || *file == '~' || *file == '$' || !paths || *paths == 0) {
+		if (access(file, F_OK) < 0) {
+			fullpath = wexpandpath(file);
+			if (!fullpath)
+				return NULL;
+
+			if (access(fullpath, F_OK) < 0) {
+				wfree(fullpath);
+				return NULL;
+			} else {
+				return fullpath;
+			}
+		} else {
+			return wstrdup(file);
+		}
+	}
+
+	flen = strlen(file);
+	tmp = paths;
+	while (*tmp) {
+		tmp = skipchar(tmp, ':');
+		if (*tmp == 0)
+			break;
+		tmp2 = nextchar(tmp, ':');
+		len = tmp2 - tmp;
+		path = wmalloc(len + flen + 2);
+		path = memcpy(path, tmp, len);
+		path[len] = 0;
+		if (path[len - 1] != '/' &&
+		    wstrlcat(path, "/", len + flen + 2) >= len + flen + 2) {
+			wfree(path);
+			return NULL;
+		}
+
+		if (wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
+			wfree(path);
+			return NULL;
+		}
+
+		fullpath = wexpandpath(path);
+		wfree(path);
+
+		if (fullpath) {
+			if (access(fullpath, F_OK) == 0) {
+				return fullpath;
+			}
+			wfree(fullpath);
+		}
+		tmp = tmp2;
+	}
+
+	return NULL;
+}
+
+char *wfindfileinlist(char *const *path_list, const char *file)
+{
+	int i;
+	char *path;
+	int len, flen;
+	char *fullpath;
+
+	if (!file)
+		return NULL;
+
+	if (*file == '/' || *file == '~' || !path_list) {
+		if (access(file, F_OK) < 0) {
+			fullpath = wexpandpath(file);
+			if (!fullpath)
+				return NULL;
+
+			if (access(fullpath, F_OK) < 0) {
+				wfree(fullpath);
+				return NULL;
+			} else {
+				return fullpath;
+			}
+		} else {
+			return wstrdup(file);
+		}
+	}
+
+	flen = strlen(file);
+	for (i = 0; path_list[i] != NULL; i++) {
+		len = strlen(path_list[i]);
+		path = wmalloc(len + flen + 2);
+		path = memcpy(path, path_list[i], len);
+		path[len] = 0;
+		if (wstrlcat(path, "/", len + flen + 2) >= len + flen + 2 ||
+		    wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
+			wfree(path);
+			return NULL;
+		}
+		/* expand tilde */
+		fullpath = wexpandpath(path);
+		wfree(path);
+		if (fullpath) {
+			/* check if file exists */
+			if (access(fullpath, F_OK) == 0) {
+				return fullpath;
+			}
+			wfree(fullpath);
+		}
+	}
+
+	return NULL;
+}
+
+char *wfindfileinarray(WMPropList *array, const char *file)
+{
+	int i;
+	char *path;
+	int len, flen;
+	char *fullpath;
+
+	if (!file)
+		return NULL;
+
+	if (*file == '/' || *file == '~' || !array) {
+		if (access(file, F_OK) < 0) {
+			fullpath = wexpandpath(file);
+			if (!fullpath)
+				return NULL;
+
+			if (access(fullpath, F_OK) < 0) {
+				wfree(fullpath);
+				return NULL;
+			} else {
+				return fullpath;
+			}
+		} else {
+			return wstrdup(file);
+		}
+	}
+
+	flen = strlen(file);
+	for (i = 0; i < WMGetPropListItemCount(array); i++) {
+		WMPropList *prop;
+		char *p;
+
+		prop = WMGetFromPLArray(array, i);
+		if (!prop)
+			continue;
+		p = WMGetFromPLString(prop);
+
+		len = strlen(p);
+		path = wmalloc(len + flen + 2);
+		path = memcpy(path, p, len);
+		path[len] = 0;
+		if (wstrlcat(path, "/", len + flen + 2) >= len + flen + 2 ||
+		    wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
+			wfree(path);
+			return NULL;
+		}
+		/* expand tilde */
+		fullpath = wexpandpath(path);
+		wfree(path);
+		if (fullpath) {
+			/* check if file exists */
+			if (access(fullpath, F_OK) == 0) {
+				return fullpath;
+			}
+			wfree(fullpath);
+		}
+	}
+	return NULL;
+}
+
+int wcopy_file(const char *dest_dir, const char *src_file, const char *dest_file)
+{
+	char *path_dst;
+	int fd_src, fd_dst;
+	struct stat stat_src;
+	mode_t permission_dst;
+	const size_t buffer_size = 2 * 1024 * 1024;	/* 4MB is a decent start choice to allow the OS to take advantage of modern disk's performance */
+	char *buffer;	/* The buffer is not created on the stack to avoid possible stack overflow as our buffer is big */
+
+ try_again_src:
+	fd_src = open(src_file, O_RDONLY | O_NOFOLLOW);
+	if (fd_src == -1) {
+		if (errno == EINTR)
+			goto try_again_src;
+		werror(_("Could not open input file \"%s\": %s"), src_file, strerror(errno));
+		return -1;
+	}
+
+	/* Only accept to copy regular files */
+	if (fstat(fd_src, &stat_src) != 0 || !S_ISREG(stat_src.st_mode)) {
+		close(fd_src);
+		return -1;
+	}
+
+	path_dst = wstrconcat(dest_dir, dest_file);
+ try_again_dst:
+	fd_dst = open(path_dst, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+	if (fd_dst == -1) {
+		if (errno == EINTR)
+			goto try_again_dst;
+		werror(_("Could not create target file \"%s\": %s"), path_dst, strerror(errno));
+		wfree(path_dst);
+		close(fd_src);
+		return -1;
+	}
+
+	buffer = malloc(buffer_size);	/* Don't use wmalloc to avoid the memset(0) we don't need */
+	if (buffer == NULL) {
+		werror(_("could not allocate memory for the copy buffer"));
+		close(fd_dst);
+		goto cleanup_and_return_failure;
+	}
+
+	for (;;) {
+		ssize_t size_data;
+		const char *write_ptr;
+		size_t write_remain;
+
+	try_again_read:
+		size_data = read(fd_src, buffer, buffer_size);
+		if (size_data == 0)
+			break; /* End of File have been reached */
+		if (size_data < 0) {
+			if (errno == EINTR)
+				goto try_again_read;
+			werror(_("could not read from file \"%s\": %s"), src_file, strerror(errno));
+			close(fd_dst);
+			goto cleanup_and_return_failure;
+		}
+
+		write_ptr = buffer;
+		write_remain = size_data;
+		while (write_remain > 0) {
+			ssize_t write_done;
+
+		try_again_write:
+			write_done = write(fd_dst, write_ptr, write_remain);
+			if (write_done < 0) {
+				if (errno == EINTR)
+					goto try_again_write;
+				werror(_("could not write data to file \"%s\": %s"), path_dst, strerror(errno));
+				close(fd_dst);
+				goto cleanup_and_return_failure;
+			}
+			write_ptr    += write_done;
+			write_remain -= write_done;
+		}
+	}
+
+	/* Keep only the permission-related part of the field: */
+	permission_dst = stat_src.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
+	if (fchmod(fd_dst, permission_dst) != 0)
+		wwarning(_("could not set permission 0%03o on file \"%s\": %s"),
+		         permission_dst, path_dst, strerror(errno));
+
+	if (close(fd_dst) != 0) {
+		werror(_("could not close the file \"%s\": %s"), path_dst, strerror(errno));
+	cleanup_and_return_failure:
+		free(buffer);
+		close(fd_src);
+		unlink(path_dst);
+		wfree(path_dst);
+		return -1;
+	}
+
+	free(buffer);
+	wfree(path_dst);
+	close(fd_src);
+
+	return 0;
+}

bazel/WINGs/handlers.c

@@ -0,0 +1,566 @@
+
+/*
+ * WINGs internal handlers: timer, idle and input handlers
+ */
+
+#include "wconfig.h"
+#include "WINGs/WINGsP.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <X11/Xos.h>
+
+#ifdef HAVE_SYS_SELECT_H
+# include <sys/select.h>
+#endif
+
+#include <time.h>
+
+#ifndef X_GETTIMEOFDAY
+#define X_GETTIMEOFDAY(t) gettimeofday(t, (struct timezone*)0)
+#endif
+
+typedef struct TimerHandler {
+	WMCallback *callback;	/* procedure to call */
+	struct timeval when;	/* when to call the callback */
+	void *clientData;
+	struct TimerHandler *next;
+	int nextDelay;		/* 0 if it's one-shot */
+} TimerHandler;
+
+typedef struct IdleHandler {
+	WMCallback *callback;
+	void *clientData;
+} IdleHandler;
+
+typedef struct InputHandler {
+	WMInputProc *callback;
+	void *clientData;
+	int fd;
+	int mask;
+} InputHandler;
+
+/* queue of timer event handlers */
+static TimerHandler *timerHandler = NULL;
+
+static WMArray *idleHandler = NULL;
+
+static WMArray *inputHandler = NULL;
+
+#define timerPending()	(timerHandler)
+
+static void rightNow(struct timeval *tv)
+{
+	X_GETTIMEOFDAY(tv);
+}
+
+/* is t1 after t2 ? */
+#define IS_AFTER(t1, t2)	(((t1).tv_sec > (t2).tv_sec) || \
+    (((t1).tv_sec == (t2).tv_sec) \
+    && ((t1).tv_usec > (t2).tv_usec)))
+
+#define IS_ZERO(tv) (tv.tv_sec == 0 && tv.tv_usec == 0)
+
+#define SET_ZERO(tv) tv.tv_sec = 0, tv.tv_usec = 0
+
+static void addmillisecs(struct timeval *tv, int milliseconds)
+{
+	tv->tv_usec += milliseconds * 1000;
+
+	tv->tv_sec += tv->tv_usec / 1000000;
+	tv->tv_usec = tv->tv_usec % 1000000;
+}
+
+static void enqueueTimerHandler(TimerHandler * handler)
+{
+	TimerHandler *tmp;
+
+	/* insert callback in queue, sorted by time left */
+	if (!timerHandler || !IS_AFTER(handler->when, timerHandler->when)) {
+		/* first in the queue */
+		handler->next = timerHandler;
+		timerHandler = handler;
+	} else {
+		tmp = timerHandler;
+		while (tmp->next && IS_AFTER(handler->when, tmp->next->when)) {
+			tmp = tmp->next;
+		}
+		handler->next = tmp->next;
+		tmp->next = handler;
+	}
+}
+
+static void delayUntilNextTimerEvent(struct timeval *delay)
+{
+	struct timeval now;
+	TimerHandler *handler;
+
+	handler = timerHandler;
+	while (handler && IS_ZERO(handler->when))
+		handler = handler->next;
+
+	if (!handler) {
+		/* The return value of this function is only valid if there _are_
+		   timers active. */
+		delay->tv_sec = 0;
+		delay->tv_usec = 0;
+		return;
+	}
+
+	rightNow(&now);
+	if (IS_AFTER(now, handler->when)) {
+		delay->tv_sec = 0;
+		delay->tv_usec = 0;
+	} else {
+		delay->tv_sec = handler->when.tv_sec - now.tv_sec;
+		delay->tv_usec = handler->when.tv_usec - now.tv_usec;
+		if (delay->tv_usec < 0) {
+			delay->tv_usec += 1000000;
+			delay->tv_sec--;
+		}
+	}
+}
+
+WMHandlerID WMAddTimerHandler(int milliseconds, WMCallback * callback, void *cdata)
+{
+	TimerHandler *handler;
+
+	handler = malloc(sizeof(TimerHandler));
+	if (!handler)
+		return NULL;
+
+	rightNow(&handler->when);
+	addmillisecs(&handler->when, milliseconds);
+	handler->callback = callback;
+	handler->clientData = cdata;
+	handler->nextDelay = 0;
+
+	enqueueTimerHandler(handler);
+
+	return handler;
+}
+
+WMHandlerID WMAddPersistentTimerHandler(int milliseconds, WMCallback * callback, void *cdata)
+{
+	TimerHandler *handler = WMAddTimerHandler(milliseconds, callback, cdata);
+
+	if (handler != NULL)
+		handler->nextDelay = milliseconds;
+
+	return handler;
+}
+
+void WMDeleteTimerWithClientData(void *cdata)
+{
+	TimerHandler *handler, *tmp;
+
+	if (!cdata || !timerHandler)
+		return;
+
+	tmp = timerHandler;
+	if (tmp->clientData == cdata) {
+		tmp->nextDelay = 0;
+		if (!IS_ZERO(tmp->when)) {
+			timerHandler = tmp->next;
+			wfree(tmp);
+		}
+	} else {
+		while (tmp->next) {
+			if (tmp->next->clientData == cdata) {
+				handler = tmp->next;
+				handler->nextDelay = 0;
+				if (IS_ZERO(handler->when))
+					break;
+				tmp->next = handler->next;
+				wfree(handler);
+				break;
+			}
+			tmp = tmp->next;
+		}
+	}
+}
+
+void WMDeleteTimerHandler(WMHandlerID handlerID)
+{
+	TimerHandler *tmp, *handler = (TimerHandler *) handlerID;
+
+	if (!handler || !timerHandler)
+		return;
+
+	tmp = timerHandler;
+
+	handler->nextDelay = 0;
+
+	if (IS_ZERO(handler->when))
+		return;
+
+	if (tmp == handler) {
+		timerHandler = handler->next;
+		wfree(handler);
+	} else {
+		while (tmp->next) {
+			if (tmp->next == handler) {
+				tmp->next = handler->next;
+				wfree(handler);
+				break;
+			}
+			tmp = tmp->next;
+		}
+	}
+}
+
+WMHandlerID WMAddIdleHandler(WMCallback * callback, void *cdata)
+{
+	IdleHandler *handler;
+
+	handler = malloc(sizeof(IdleHandler));
+	if (!handler)
+		return NULL;
+
+	handler->callback = callback;
+	handler->clientData = cdata;
+	/* add handler at end of queue */
+	if (!idleHandler) {
+		idleHandler = WMCreateArrayWithDestructor(16, wfree);
+	}
+	WMAddToArray(idleHandler, handler);
+
+	return handler;
+}
+
+void WMDeleteIdleHandler(WMHandlerID handlerID)
+{
+	IdleHandler *handler = (IdleHandler *) handlerID;
+
+	if (!handler || !idleHandler)
+		return;
+
+	WMRemoveFromArray(idleHandler, handler);
+}
+
+WMHandlerID WMAddInputHandler(int fd, int condition, WMInputProc * proc, void *clientData)
+{
+	InputHandler *handler;
+
+	handler = wmalloc(sizeof(InputHandler));
+
+	handler->fd = fd;
+	handler->mask = condition;
+	handler->callback = proc;
+	handler->clientData = clientData;
+
+	if (!inputHandler)
+		inputHandler = WMCreateArrayWithDestructor(16, wfree);
+	WMAddToArray(inputHandler, handler);
+
+	return handler;
+}
+
+void WMDeleteInputHandler(WMHandlerID handlerID)
+{
+	InputHandler *handler = (InputHandler *) handlerID;
+
+	if (!handler || !inputHandler)
+		return;
+
+	WMRemoveFromArray(inputHandler, handler);
+}
+
+Bool W_CheckIdleHandlers(void)
+{
+	IdleHandler *handler;
+	WMArray *handlerCopy;
+	WMArrayIterator iter;
+
+	if (!idleHandler || WMGetArrayItemCount(idleHandler) == 0) {
+		W_FlushIdleNotificationQueue();
+		/* make sure an observer in queue didn't added an idle handler */
+		return (idleHandler != NULL && WMGetArrayItemCount(idleHandler) > 0);
+	}
+
+	handlerCopy = WMDuplicateArray(idleHandler);
+
+	WM_ITERATE_ARRAY(handlerCopy, handler, iter) {
+		/* check if the handler still exist or was removed by a callback */
+		if (WMGetFirstInArray(idleHandler, handler) == WANotFound)
+			continue;
+
+		(*handler->callback) (handler->clientData);
+		WMDeleteIdleHandler(handler);
+	}
+
+	WMFreeArray(handlerCopy);
+
+	W_FlushIdleNotificationQueue();
+
+	/* this is not necesarrily False, because one handler can re-add itself */
+	return (WMGetArrayItemCount(idleHandler) > 0);
+}
+
+void W_CheckTimerHandlers(void)
+{
+	TimerHandler *handler;
+	struct timeval now;
+
+	if (!timerHandler) {
+		W_FlushASAPNotificationQueue();
+		return;
+	}
+
+	rightNow(&now);
+
+	handler = timerHandler;
+	while (handler && IS_AFTER(now, handler->when)) {
+		if (!IS_ZERO(handler->when)) {
+			SET_ZERO(handler->when);
+			(*handler->callback) (handler->clientData);
+		}
+		handler = handler->next;
+	}
+
+	while (timerHandler && IS_ZERO(timerHandler->when)) {
+		handler = timerHandler;
+		timerHandler = timerHandler->next;
+
+		if (handler->nextDelay > 0) {
+			handler->when = now;
+			addmillisecs(&handler->when, handler->nextDelay);
+			enqueueTimerHandler(handler);
+		} else {
+			wfree(handler);
+		}
+	}
+
+	W_FlushASAPNotificationQueue();
+}
+
+/*
+ * This functions will handle input events on all registered file descriptors.
+ * Input:
+ *    - waitForInput - True if we want the function to wait until an event
+ *                     appears on a file descriptor we watch, False if we
+ *                     want the function to immediately return if there is
+ *                     no data available on the file descriptors we watch.
+ *    - inputfd      - Extra input file descriptor to watch for input.
+ *                     This is only used when called from wevent.c to watch
+ *                     on ConnectionNumber(dpy) to avoid blocking of X events
+ *                     if we wait for input from other file handlers.
+ * Output:
+ *    if waitForInput is False, the function will return False if there are no
+ *                     input handlers registered, or if there is no data
+ *                     available on the registered ones, and will return True
+ *                     if there is at least one input handler that has data
+ *                     available.
+ *    if waitForInput is True, the function will return False if there are no
+ *                     input handlers registered, else it will block until an
+ *                     event appears on one of the file descriptors it watches
+ *                     and then it will return True.
+ *
+ * If the retured value is True, the input handlers for the corresponding file
+ * descriptors are also called.
+ *
+ * Parametersshould be passed like this:
+ * - from wevent.c:
+ *   waitForInput - apropriate value passed by the function who called us
+ *   inputfd = ConnectionNumber(dpy)
+ * - from wutil.c:
+ *   waitForInput - apropriate value passed by the function who called us
+ *   inputfd = -1
+ *
+ */
+Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
+{
+#if defined(HAVE_POLL) && defined(HAVE_POLL_H) && !defined(HAVE_SELECT)
+	struct poll fd *fds;
+	InputHandler *handler;
+	int count, timeout, nfds, i, extrafd;
+
+	extrafd = (inputfd < 0) ? 0 : 1;
+
+	if (inputHandler)
+		nfds = WMGetArrayItemCount(inputHandler);
+	else
+		nfds = 0;
+
+	if (!extrafd && nfds == 0) {
+		W_FlushASAPNotificationQueue();
+		return False;
+	}
+
+	fds = wmalloc((nfds + extrafd) * sizeof(struct pollfd));
+	if (extrafd) {
+		/* put this to the end of array to avoid using ranges from 1 to nfds+1 */
+		fds[nfds].fd = inputfd;
+		fds[nfds].events = POLLIN;
+	}
+
+	/* use WM_ITERATE_ARRAY() here */
+	for (i = 0; i < nfds; i++) {
+		handler = WMGetFromArray(inputHandler, i);
+		fds[i].fd = handler->fd;
+		fds[i].events = 0;
+		if (handler->mask & WIReadMask)
+			fds[i].events |= POLLIN;
+
+		if (handler->mask & WIWriteMask)
+			fds[i].events |= POLLOUT;
+
+#if 0				/* FIXME */
+		if (handler->mask & WIExceptMask)
+			FD_SET(handler->fd, &eset);
+#endif
+	}
+
+	/*
+	 * Setup the timeout to the estimated time until the
+	 * next timer expires.
+	 */
+	if (!waitForInput) {
+		timeout = 0;
+	} else if (timerPending()) {
+		struct timeval tv;
+		delayUntilNextTimerEvent(&tv);
+		timeout = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+	} else {
+		timeout = -1;
+	}
+
+	count = poll(fds, nfds + extrafd, timeout);
+
+	if (count > 0 && nfds > 0) {
+		WMArray *handlerCopy = WMDuplicateArray(inputHandler);
+		int mask;
+
+		/* use WM_ITERATE_ARRAY() here */
+		for (i = 0; i < nfds; i++) {
+			handler = WMGetFromArray(handlerCopy, i);
+			/* check if the handler still exist or was removed by a callback */
+			if (WMGetFirstInArray(inputHandler, handler) == WANotFound)
+				continue;
+
+			mask = 0;
+
+			if ((handler->mask & WIReadMask) &&
+			    (fds[i].revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)))
+				mask |= WIReadMask;
+
+			if ((handler->mask & WIWriteMask) && (fds[i].revents & (POLLOUT | POLLWRBAND)))
+				mask |= WIWriteMask;
+
+			if ((handler->mask & WIExceptMask) && (fds[i].revents & (POLLHUP | POLLNVAL | POLLERR)))
+				mask |= WIExceptMask;
+
+			if (mask != 0 && handler->callback) {
+				(*handler->callback) (handler->fd, mask, handler->clientData);
+			}
+		}
+
+		WMFreeArray(handlerCopy);
+	}
+
+	wfree(fds);
+
+	W_FlushASAPNotificationQueue();
+
+	return (count > 0);
+#else
+#ifdef HAVE_SELECT
+	struct timeval timeout;
+	struct timeval *timeoutPtr;
+	fd_set rset, wset, eset;
+	int maxfd, nfds, i;
+	int count;
+	InputHandler *handler;
+
+	if (inputHandler)
+		nfds = WMGetArrayItemCount(inputHandler);
+	else
+		nfds = 0;
+
+	if (inputfd < 0 && nfds == 0) {
+		W_FlushASAPNotificationQueue();
+		return False;
+	}
+
+	FD_ZERO(&rset);
+	FD_ZERO(&wset);
+	FD_ZERO(&eset);
+
+	if (inputfd < 0) {
+		maxfd = 0;
+	} else {
+		FD_SET(inputfd, &rset);
+		maxfd = inputfd;
+	}
+
+	/* use WM_ITERATE_ARRAY() here */
+	for (i = 0; i < nfds; i++) {
+		handler = WMGetFromArray(inputHandler, i);
+		if (handler->mask & WIReadMask)
+			FD_SET(handler->fd, &rset);
+
+		if (handler->mask & WIWriteMask)
+			FD_SET(handler->fd, &wset);
+
+		if (handler->mask & WIExceptMask)
+			FD_SET(handler->fd, &eset);
+
+		if (maxfd < handler->fd)
+			maxfd = handler->fd;
+	}
+
+	/*
+	 * Setup the timeout to the estimated time until the
+	 * next timer expires.
+	 */
+	if (!waitForInput) {
+		SET_ZERO(timeout);
+		timeoutPtr = &timeout;
+	} else if (timerPending()) {
+		delayUntilNextTimerEvent(&timeout);
+		timeoutPtr = &timeout;
+	} else {
+		timeoutPtr = (struct timeval *)0;
+	}
+
+	count = select(1 + maxfd, &rset, &wset, &eset, timeoutPtr);
+
+	if (count > 0 && nfds > 0) {
+		WMArray *handlerCopy = WMDuplicateArray(inputHandler);
+		int mask;
+
+		/* use WM_ITERATE_ARRAY() here */
+		for (i = 0; i < nfds; i++) {
+			handler = WMGetFromArray(handlerCopy, i);
+			/* check if the handler still exist or was removed by a callback */
+			if (WMGetFirstInArray(inputHandler, handler) == WANotFound)
+				continue;
+
+			mask = 0;
+
+			if ((handler->mask & WIReadMask) && FD_ISSET(handler->fd, &rset))
+				mask |= WIReadMask;
+
+			if ((handler->mask & WIWriteMask) && FD_ISSET(handler->fd, &wset))
+				mask |= WIWriteMask;
+
+			if ((handler->mask & WIExceptMask) && FD_ISSET(handler->fd, &eset))
+				mask |= WIExceptMask;
+
+			if (mask != 0 && handler->callback) {
+				(*handler->callback) (handler->fd, mask, handler->clientData);
+			}
+		}
+
+		WMFreeArray(handlerCopy);
+	}
+
+	W_FlushASAPNotificationQueue();
+
+	return (count > 0);
+#else				/* not HAVE_SELECT, not HAVE_POLL */
+# error   Neither select nor poll. You lose.
+#endif				/* HAVE_SELECT */
+#endif				/* HAVE_POLL */
+}

bazel/WINGs/hashtable.c

@@ -0,0 +1,422 @@
+#include "config/config.h"
+
+#include <sys/types.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "WINGs/WUtil.h"
+
+#define INITIAL_CAPACITY	23
+
+
+typedef struct HashItem {
+	const void *key;
+	const void *data;
+
+	struct HashItem *next;	/* collided item list */
+} HashItem;
+
+typedef struct W_HashTable {
+	WMHashTableCallbacks callbacks;
+
+	unsigned itemCount;
+	unsigned size;		/* table size */
+
+	HashItem **table;
+} HashTable;
+
+#define HASH(table, key)  (((table)->callbacks.hash ? \
+    (*(table)->callbacks.hash)(key) : hashPtr(key)) % (table)->size)
+
+#define DUPKEY(table, key) ((table)->callbacks.retainKey ? \
+    (*(table)->callbacks.retainKey)(key) : (key))
+
+#define RELKEY(table, key) if ((table)->callbacks.releaseKey) \
+    (*(table)->callbacks.releaseKey)(key)
+
+static inline unsigned hashString(const void *param)
+{
+	const char *key = param;
+	unsigned ret = 0;
+	unsigned ctr = 0;
+
+	while (*key) {
+		ret ^= *key++ << ctr;
+		ctr = (ctr + 1) % sizeof(char *);
+	}
+
+	return ret;
+}
+
+static inline unsigned hashPtr(const void *key)
+{
+	return ((size_t) key / sizeof(char *));
+}
+
+static void rellocateItem(WMHashTable * table, HashItem * item)
+{
+	unsigned h;
+
+	h = HASH(table, item->key);
+
+	item->next = table->table[h];
+	table->table[h] = item;
+}
+
+static void rebuildTable(WMHashTable * table)
+{
+	HashItem *next;
+	HashItem **oldArray;
+	int i;
+	int oldSize;
+	int newSize;
+
+	oldArray = table->table;
+	oldSize = table->size;
+
+	newSize = table->size * 2;
+
+	table->table = wmalloc(sizeof(char *) * newSize);
+	table->size = newSize;
+
+	for (i = 0; i < oldSize; i++) {
+		while (oldArray[i] != NULL) {
+			next = oldArray[i]->next;
+			rellocateItem(table, oldArray[i]);
+			oldArray[i] = next;
+		}
+	}
+	wfree(oldArray);
+}
+
+WMHashTable *WMCreateHashTable(const WMHashTableCallbacks callbacks)
+{
+	HashTable *table;
+
+	table = wmalloc(sizeof(HashTable));
+
+	table->callbacks = callbacks;
+
+	table->size = INITIAL_CAPACITY;
+
+	table->table = wmalloc(sizeof(HashItem *) * table->size);
+
+	return table;
+}
+
+void WMResetHashTable(WMHashTable * table)
+{
+	HashItem *item, *tmp;
+	int i;
+
+	for (i = 0; i < table->size; i++) {
+		item = table->table[i];
+		while (item) {
+			tmp = item->next;
+			RELKEY(table, item->key);
+			wfree(item);
+			item = tmp;
+		}
+	}
+
+	table->itemCount = 0;
+
+	if (table->size > INITIAL_CAPACITY) {
+		wfree(table->table);
+		table->size = INITIAL_CAPACITY;
+		table->table = wmalloc(sizeof(HashItem *) * table->size);
+	} else {
+		memset(table->table, 0, sizeof(HashItem *) * table->size);
+	}
+}
+
+void WMFreeHashTable(WMHashTable * table)
+{
+	HashItem *item, *tmp;
+	int i;
+
+	for (i = 0; i < table->size; i++) {
+		item = table->table[i];
+		while (item) {
+			tmp = item->next;
+			RELKEY(table, item->key);
+			wfree(item);
+			item = tmp;
+		}
+	}
+	wfree(table->table);
+	wfree(table);
+}
+
+unsigned WMCountHashTable(WMHashTable * table)
+{
+	return table->itemCount;
+}
+
+static HashItem *hashGetItem(WMHashTable *table, const void *key)
+{
+	unsigned h;
+	HashItem *item;
+
+	h = HASH(table, key);
+	item = table->table[h];
+
+	if (table->callbacks.keyIsEqual) {
+		while (item) {
+			if ((*table->callbacks.keyIsEqual) (key, item->key)) {
+				break;
+			}
+			item = item->next;
+		}
+	} else {
+		while (item) {
+			if (key == item->key) {
+				break;
+			}
+			item = item->next;
+		}
+	}
+	return item;
+}
+
+void *WMHashGet(WMHashTable * table, const void *key)
+{
+	HashItem *item;
+
+	item = hashGetItem(table, key);
+	if (!item)
+		return NULL;
+	return (void *)item->data;
+}
+
+Bool WMHashGetItemAndKey(WMHashTable * table, const void *key, void **retItem, void **retKey)
+{
+	HashItem *item;
+
+	item = hashGetItem(table, key);
+	if (!item)
+		return False;
+
+	if (retKey)
+		*retKey = (void *)item->key;
+	if (retItem)
+		*retItem = (void *)item->data;
+	return True;
+}
+
+void *WMHashInsert(WMHashTable * table, const void *key, const void *data)
+{
+	unsigned h;
+	HashItem *item;
+	int replacing = 0;
+
+	h = HASH(table, key);
+	/* look for the entry */
+	item = table->table[h];
+	if (table->callbacks.keyIsEqual) {
+		while (item) {
+			if ((*table->callbacks.keyIsEqual) (key, item->key)) {
+				replacing = 1;
+				break;
+			}
+			item = item->next;
+		}
+	} else {
+		while (item) {
+			if (key == item->key) {
+				replacing = 1;
+				break;
+			}
+			item = item->next;
+		}
+	}
+
+	if (replacing) {
+		const void *old;
+
+		old = item->data;
+		item->data = data;
+		RELKEY(table, item->key);
+		item->key = DUPKEY(table, key);
+
+		return (void *)old;
+	} else {
+		HashItem *nitem;
+
+		nitem = wmalloc(sizeof(HashItem));
+		nitem->key = DUPKEY(table, key);
+		nitem->data = data;
+		nitem->next = table->table[h];
+		table->table[h] = nitem;
+
+		table->itemCount++;
+	}
+
+	/* OPTIMIZE: put this in an idle handler. */
+	if (table->itemCount > table->size) {
+#ifdef DEBUG0
+		printf("rebuilding hash table...\n");
+#endif
+		rebuildTable(table);
+#ifdef DEBUG0
+		printf("finished rebuild.\n");
+#endif
+	}
+
+	return NULL;
+}
+
+static HashItem *deleteFromList(HashTable * table, HashItem * item, const void *key)
+{
+	HashItem *next;
+
+	if (item == NULL)
+		return NULL;
+
+	if ((table->callbacks.keyIsEqual && (*table->callbacks.keyIsEqual) (key, item->key))
+	    || (!table->callbacks.keyIsEqual && key == item->key)) {
+
+		next = item->next;
+		RELKEY(table, item->key);
+		wfree(item);
+
+		table->itemCount--;
+
+		return next;
+	}
+
+	item->next = deleteFromList(table, item->next, key);
+
+	return item;
+}
+
+void WMHashRemove(WMHashTable * table, const void *key)
+{
+	unsigned h;
+
+	h = HASH(table, key);
+
+	table->table[h] = deleteFromList(table, table->table[h], key);
+}
+
+WMHashEnumerator WMEnumerateHashTable(WMHashTable * table)
+{
+	WMHashEnumerator enumerator;
+
+	enumerator.table = table;
+	enumerator.index = 0;
+	enumerator.nextItem = table->table[0];
+
+	return enumerator;
+}
+
+void *WMNextHashEnumeratorItem(WMHashEnumerator * enumerator)
+{
+	const void *data = NULL;
+
+	/* this assumes the table doesn't change between
+	 * WMEnumerateHashTable() and WMNextHashEnumeratorItem() calls */
+
+	if (enumerator->nextItem == NULL) {
+		HashTable *table = enumerator->table;
+		while (++enumerator->index < table->size) {
+			if (table->table[enumerator->index] != NULL) {
+				enumerator->nextItem = table->table[enumerator->index];
+				break;
+			}
+		}
+	}
+
+	if (enumerator->nextItem) {
+		data = ((HashItem *) enumerator->nextItem)->data;
+		enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
+	}
+
+	return (void *)data;
+}
+
+void *WMNextHashEnumeratorKey(WMHashEnumerator * enumerator)
+{
+	const void *key = NULL;
+
+	/* this assumes the table doesn't change between
+	 * WMEnumerateHashTable() and WMNextHashEnumeratorKey() calls */
+
+	if (enumerator->nextItem == NULL) {
+		HashTable *table = enumerator->table;
+		while (++enumerator->index < table->size) {
+			if (table->table[enumerator->index] != NULL) {
+				enumerator->nextItem = table->table[enumerator->index];
+				break;
+			}
+		}
+	}
+
+	if (enumerator->nextItem) {
+		key = ((HashItem *) enumerator->nextItem)->key;
+		enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
+	}
+
+	return (void *)key;
+}
+
+Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator * enumerator, void **item, void **key)
+{
+	/* this assumes the table doesn't change between
+	 * WMEnumerateHashTable() and WMNextHashEnumeratorItemAndKey() calls */
+
+	if (enumerator->nextItem == NULL) {
+		HashTable *table = enumerator->table;
+		while (++enumerator->index < table->size) {
+			if (table->table[enumerator->index] != NULL) {
+				enumerator->nextItem = table->table[enumerator->index];
+				break;
+			}
+		}
+	}
+
+	if (enumerator->nextItem) {
+		if (item)
+			*item = (void *)((HashItem *) enumerator->nextItem)->data;
+		if (key)
+			*key = (void *)((HashItem *) enumerator->nextItem)->key;
+		enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
+
+		return True;
+	}
+
+	return False;
+}
+
+static Bool compareStrings(const void *param1, const void *param2)
+{
+	const char *key1 = param1;
+	const char *key2 = param2;
+
+	return strcmp(key1, key2) == 0;
+}
+
+typedef void *(*retainFunc) (const void *);
+typedef void (*releaseFunc) (const void *);
+
+const WMHashTableCallbacks WMIntHashCallbacks = {
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+const WMHashTableCallbacks WMStringHashCallbacks = {
+	hashString,
+	compareStrings,
+	(retainFunc) wstrdup,
+	(releaseFunc) wfree
+};
+
+const WMHashTableCallbacks WMStringPointerHashCallbacks = {
+	hashString,
+	compareStrings,
+	NULL,
+	NULL
+};

bazel/WINGs/make-rgb

@@ -0,0 +1,53 @@
+#!/usr/bin/python
+
+import sys
+import re
+from optparse import OptionParser
+
+parser = OptionParser(version="%prog 1.0")
+parser.add_option("-f", "--file", dest="rgbtxtFile", default='/etc/X11/rgb.txt',
+                  help="rgb.txt file containing X11 colors (/etc/X11/rgb.txt)",
+                  metavar="File")
+
+(options, args) = parser.parse_args()
+
+f = open(options.rgbtxtFile)
+lines = f.readlines()
+f.close()
+
+colorLine = re.compile(r'''\s*
+                           (?P<red>\d+)       # red
+                           \s+
+                           (?P<green>\d+)     # green
+                           \s+
+                           (?P<blue>\d+)      # blue
+                           \s+
+                           (?P<name>[^\s]+)   # name
+                           ''', re.VERBOSE)
+
+print '''
+/* Automatically generated file. Do NOT edit. Regenerate it using make-rgb */
+
+#ifndef RGB_H_
+#define RGB_H_
+
+#include <wraster.h>
+
+typedef struct RGBColor {
+    RColor color;
+    char *name;
+} RGBColor;
+
+RGBColor rgbColors[] = {'''
+
+for line in lines:
+    m = colorLine.match(line)
+    if m:
+        print '''    {{%(red)3s, %(green)3s, %(blue)3s, 0}, "%(name)s"},''' % m.groupdict()
+
+print '''    {{  0,   0,   0, 0}, NULL}
+};
+
+#endif
+'''
+

bazel/WINGs/memory.c

@@ -0,0 +1,223 @@
+/*
+ *  Window Maker miscelaneous function library
+ *
+ *  Copyright (c) 1997-2003 Alfredo K. Kojima
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ *  MA 02110-1301, USA.
+ */
+
+#include "wconfig.h"
+#include "WUtil.h"
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <signal.h>
+
+#ifdef HAVE_STDNORETURN
+#include <stdnoreturn.h>
+#endif
+
+#ifdef USE_BOEHM_GC
+#ifndef GC_DEBUG
+#define GC_DEBUG
+#endif /* !GC_DEBUG */
+#include <gc/gc.h>
+#endif /* USE_BOEHM_GC */
+
+#ifndef False
+# define False 0
+#endif
+#ifndef True
+# define True 1
+#endif
+
+static void defaultHandler(int bla)
+{
+	if (bla)
+		kill(getpid(), SIGABRT);
+	else
+		exit(1);
+}
+
+static waborthandler *aborthandler = defaultHandler;
+
+static inline noreturn void wAbort(int bla)
+{
+	(*aborthandler)(bla);
+	exit(-1);
+}
+
+waborthandler *wsetabort(waborthandler * handler)
+{
+	waborthandler *old = aborthandler;
+
+	aborthandler = handler;
+
+	return old;
+}
+
+static int Aborting = 0;	/* if we're in the middle of an emergency exit */
+
+static WMHashTable *table = NULL;
+
+void *wmalloc(size_t size)
+{
+	void *tmp;
+
+	assert(size > 0);
+
+#ifdef USE_BOEHM_GC
+	tmp = GC_MALLOC(size);
+#else
+	tmp = malloc(size);
+#endif
+	if (tmp == NULL) {
+		wwarning("malloc() failed. Retrying after 2s.");
+		sleep(2);
+#ifdef USE_BOEHM_GC
+		tmp = GC_MALLOC(size);
+#else
+		tmp = malloc(size);
+#endif
+		if (tmp == NULL) {
+			if (Aborting) {
+				fputs("Really Bad Error: recursive malloc() failure.", stderr);
+				exit(-1);
+			} else {
+				wfatal("virtual memory exhausted");
+				Aborting = 1;
+				wAbort(False);
+			}
+		}
+	}
+	if (tmp != NULL)
+		memset(tmp, 0, size);
+	return tmp;
+}
+
+void *wrealloc(void *ptr, size_t newsize)
+{
+	void *nptr;
+
+	if (!ptr) {
+		nptr = wmalloc(newsize);
+	} else if (newsize == 0) {
+		wfree(ptr);
+		nptr = NULL;
+	} else {
+#ifdef USE_BOEHM_GC
+		nptr = GC_REALLOC(ptr, newsize);
+#else
+		nptr = realloc(ptr, newsize);
+#endif
+		if (nptr == NULL) {
+			wwarning("realloc() failed. Retrying after 2s.");
+			sleep(2);
+#ifdef USE_BOEHM_GC
+			nptr = GC_REALLOC(ptr, newsize);
+#else
+			nptr = realloc(ptr, newsize);
+#endif
+			if (nptr == NULL) {
+				if (Aborting) {
+					fputs("Really Bad Error: recursive realloc() failure.", stderr);
+					exit(-1);
+				} else {
+					wfatal("virtual memory exhausted");
+					Aborting = 1;
+					wAbort(False);
+				}
+			}
+		}
+	}
+	return nptr;
+}
+
+void *wretain(void *ptr)
+{
+	int *refcount;
+
+	if (!table) {
+		table = WMCreateHashTable(WMIntHashCallbacks);
+	}
+
+	refcount = WMHashGet(table, ptr);
+	if (!refcount) {
+		refcount = wmalloc(sizeof(int));
+		*refcount = 1;
+		WMHashInsert(table, ptr, refcount);
+#ifdef VERBOSE
+		printf("== %i (%p)\n", *refcount, ptr);
+#endif
+	} else {
+		(*refcount)++;
+#ifdef VERBOSE
+		printf("+ %i (%p)\n", *refcount, ptr);
+#endif
+	}
+
+	return ptr;
+}
+
+void wfree(void *ptr)
+{
+	if (ptr)
+#ifdef USE_BOEHM_GC
+		/* This should eventually be removed, once the criss-cross
+		 * of wmalloc()d memory being free()d, malloc()d memory being
+		 * wfree()d, various misuses of calling wfree() on objects
+		 * allocated by libc malloc() and calling libc free() on
+		 * objects allocated by Boehm GC (think external libraries)
+		 * is cleaned up.
+		 */
+		if (GC_base(ptr) != 0)
+			GC_FREE(ptr);
+		else
+			free(ptr);
+#else
+		free(ptr);
+#endif
+	ptr = NULL;
+}
+
+void wrelease(void *ptr)
+{
+	int *refcount;
+
+	refcount = WMHashGet(table, ptr);
+	if (!refcount) {
+		wwarning("trying to release unexisting data %p", ptr);
+	} else {
+		(*refcount)--;
+		if (*refcount < 1) {
+#ifdef VERBOSE
+			printf("RELEASING %p\n", ptr);
+#endif
+			WMHashRemove(table, ptr);
+			wfree(refcount);
+			wfree(ptr);
+		}
+#ifdef VERBOSE
+		else {
+			printf("- %i (%p)\n", *refcount, ptr);
+		}
+#endif
+	}
+}

bazel/WINGs/menuparser.c

@@ -0,0 +1,652 @@
+/*
+ *  Window Maker window manager
+ *
+ *  Copyright (c) 2012 Christophe Curis
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "wconfig.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+#include "WINGs/WUtil.h"
+
+#include "WINGs/menuparser.h"
+
+static WMenuParser menu_parser_create_new(const char *file_name, void *file,
+					  const char *include_default_paths);
+static char *menu_parser_isolate_token(WMenuParser parser);
+static void menu_parser_get_directive(WMenuParser parser);
+static Bool menu_parser_include_file(WMenuParser parser);
+static void menu_parser_condition_ifmacro(WMenuParser parser, Bool check_exists);
+static void menu_parser_condition_else(WMenuParser parser);
+static void menu_parser_condition_end(WMenuParser parser);
+
+
+/* Constructor and Destructor for the Menu Parser object */
+WMenuParser WMenuParserCreate(const char *file_name, void *file,
+			      const char *include_default_paths)
+{
+	WMenuParser parser;
+
+	parser = menu_parser_create_new(file_name, file, include_default_paths);
+	menu_parser_register_preset_macros(parser);
+	return parser;
+}
+
+void WMenuParserDelete(WMenuParser parser)
+{
+	if (parser->include_file) {
+		/* Trick: the top parser's data are not wmalloc'd, we point on the
+		 * provided data so we do not wfree it; however for include files
+		 * we did wmalloc them.
+		 * This code should not be used as the wfree is done when we reach
+		 * the end of an include file; however this may not happen when an
+		 * early exit occurs (typically when 'readMenuFile' does not find
+		 * its expected command). */
+		fclose(parser->include_file->file_handle);
+		wfree((char *) parser->include_file->file_name);
+		WMenuParserDelete(parser->include_file);
+	}
+
+	if (parser->macros)
+		menu_parser_free_macros(parser);
+
+	wfree(parser);
+}
+
+static WMenuParser menu_parser_create_new(const char *file_name, void *file,
+					  const char *include_default_paths)
+{
+	WMenuParser parser;
+
+	parser = wmalloc(sizeof(*parser));
+	parser->include_default_paths = include_default_paths;
+	parser->file_name = file_name;
+	parser->file_handle = file;
+	parser->rd = parser->line_buffer;
+
+	return parser;
+}
+
+/* To report helpfull messages to user */
+const char *WMenuParserGetFilename(WMenuParser parser)
+{
+	return parser->file_name;
+}
+
+void WMenuParserError(WMenuParser parser, const char *msg, ...)
+{
+	char buf[MAXLINE];
+	va_list args;
+	WMenuParser parent;
+
+	while (parser->include_file)
+		parser = parser->include_file;
+
+	va_start(args, msg);
+	vsnprintf(buf, sizeof(buf), msg, args);
+	va_end(args);
+	__wmessage("WMenuParser", parser->file_name, parser->line_number,
+		   WMESSAGE_TYPE_WARNING, "%s", buf);
+
+	for (parent = parser->parent_file; parent != NULL; parent = parent->parent_file)
+		__wmessage("WMenuParser", parser->file_name, parser->line_number,
+			   WMESSAGE_TYPE_WARNING, _("   included from file \"%s\" at line %d"),
+			   parent->file_name, parent->line_number);
+}
+
+/* Read one line from file and split content
+ * The function returns False when the end of file is reached */
+Bool WMenuParserGetLine(WMenuParser top_parser, char **title, char **command,
+			char **parameter, char **shortcut)
+{
+	WMenuParser cur_parser;
+	enum { GET_TITLE, GET_COMMAND, GET_PARAMETERS, GET_SHORTCUT } scanmode;
+	char *token, *params = NULL;
+	char lineparam[MAXLINE];
+
+	lineparam[0] = '\0';
+	*title = NULL;
+	*command = NULL;
+	*parameter = NULL;
+	*shortcut = NULL;
+	scanmode = GET_TITLE;
+
+read_next_line_with_filechange:
+	cur_parser = top_parser;
+	while (cur_parser->include_file)
+		cur_parser = cur_parser->include_file;
+
+read_next_line:
+	if (fgets(cur_parser->line_buffer, sizeof(cur_parser->line_buffer), cur_parser->file_handle) == NULL) {
+		if (cur_parser->cond.depth > 0) {
+			int i;
+
+			for (i = 0; i < cur_parser->cond.depth; i++)
+				WMenuParserError(cur_parser, _("missing #endif to match #%s at line %d"),
+						 cur_parser->cond.stack[i].name, cur_parser->cond.stack[i].line);
+		}
+
+		if (cur_parser->parent_file == NULL)
+			/* Not inside an included file -> we have reached the end */
+			return False;
+
+		/* We have only reached the end of an included file -> go back to calling file */
+		fclose(cur_parser->file_handle);
+		wfree((char *) cur_parser->file_name);
+		cur_parser = cur_parser->parent_file;
+		wfree(cur_parser->include_file);
+		cur_parser->include_file = NULL;
+		goto read_next_line_with_filechange;
+	}
+
+	cur_parser->line_number++;
+	cur_parser->rd = cur_parser->line_buffer;
+
+	for (;;) {
+		if (!menu_parser_skip_spaces_and_comments(cur_parser)) {
+			/* We reached the end of line */
+			if (scanmode == GET_TITLE)
+				goto read_next_line;	/* Empty line -> skip */
+			else
+				break;			/* Finished reading current line -> return it to caller */
+		}
+
+		if ((scanmode == GET_TITLE) && (*cur_parser->rd == '#')) {
+			cur_parser->rd++;
+			menu_parser_get_directive(cur_parser);
+			goto read_next_line_with_filechange;
+		}
+
+		if (cur_parser->cond.stack[0].skip)
+			goto read_next_line;
+
+		/* Found a word */
+		token = menu_parser_isolate_token(cur_parser);
+		switch (scanmode) {
+		case GET_TITLE:
+			*title = token;
+			scanmode = GET_COMMAND;
+			break;
+
+		case GET_COMMAND:
+			if (strcmp(token, "SHORTCUT") == 0) {
+				scanmode = GET_SHORTCUT;
+				wfree(token);
+			} else {
+				*command = token;
+				scanmode = GET_PARAMETERS;
+			}
+			break;
+
+		case GET_SHORTCUT:
+			if (*shortcut != NULL) {
+				WMenuParserError(top_parser, _("multiple SHORTCUT definition not valid") );
+				wfree(*shortcut);
+			}
+			*shortcut = token;
+			scanmode = GET_COMMAND;
+			break;
+
+		case GET_PARAMETERS:
+			{
+				char *src;
+
+				if (params == NULL) {
+					params = lineparam;
+				} else {
+					if ((params - lineparam) < sizeof(lineparam) - 1)
+						*params++ = ' ';
+				}
+
+				src = token;
+				while ((params - lineparam) < sizeof(lineparam) - 1)
+					if ( (*params = *src++) == '\0')
+						break;
+					else
+						params++;
+				wfree(token);
+			}
+			break;
+		}
+	}
+
+	if (params != NULL) {
+		lineparam[sizeof(lineparam) - 1] = '\0';
+		*parameter = wstrdup(lineparam);
+	}
+
+	return True;
+}
+
+/* Return False when there's nothing left on the line,
+   otherwise increment parser's pointer to next token */
+Bool menu_parser_skip_spaces_and_comments(WMenuParser parser)
+{
+	for (;;) {
+		while (isspace(*parser->rd))
+			parser->rd++;
+
+		if (*parser->rd == '\0') {
+			return False; /* Found the end of current line */
+		} else if ((parser->rd[0] == '\\') &&
+			   (parser->rd[1] == '\n') &&
+			   (parser->rd[2] == '\0')) {
+			/* Means that the current line is expected to be continued on next line */
+			if (fgets(parser->line_buffer, sizeof(parser->line_buffer), parser->file_handle) == NULL) {
+				WMenuParserError(parser, _("premature end of file while expecting a new line after '\\'") );
+				return False;
+			}
+			parser->line_number++;
+			parser->rd = parser->line_buffer;
+
+		} else if (parser->rd[0] == '/') {
+			if (parser->rd[1] == '/')	/* Single line C comment */
+				return False;		/* Won't find anything more on this line */
+
+			if (parser->rd[1] == '*') {
+				int start_line;
+
+				start_line = parser->line_number;
+				parser->rd += 2;
+				for (;;) {
+					/* Search end-of-comment marker */
+					while (*parser->rd != '\0') {
+						if ((parser->rd[0] == '*') && (parser->rd[1] == '/'))
+							goto found_end_of_comment;
+
+						parser->rd++;
+					}
+
+					/* Marker not found -> load next line */
+					if (fgets(parser->line_buffer, sizeof(parser->line_buffer), parser->file_handle) == NULL) {
+						WMenuParserError(parser, _("reached end of file while searching '*/' for comment started at line %d"), start_line);
+						return False;
+					}
+
+					parser->line_number++;
+					parser->rd = parser->line_buffer;
+				}
+
+found_end_of_comment:
+				parser->rd += 2;	/* Skip closing mark */
+				continue;		/* Because there may be spaces after the comment */
+			}
+
+			return True;			/* the '/' was not a comment, treat it as user data */
+		} else {
+			return True;			/* Found some data */
+		}
+	}
+}
+
+/* read a token (non-spaces suite of characters)
+ * the result is wmalloc's, so it needs to be free'd */
+static char *menu_parser_isolate_token(WMenuParser parser)
+{
+	char buffer_token[sizeof(parser->line_buffer)];
+	char *token;
+	int limit = MAX_NESTED_MACROS;
+
+	token = buffer_token;
+
+restart_token_split:
+
+	while (*parser->rd != '\0')
+		if (isspace(*parser->rd)) {
+			break;
+
+		} else if ((parser->rd[0] == '/') &&
+			 ((parser->rd[1] == '*') || (parser->rd[1] == '/'))) {
+			break;
+
+		} else if (parser->rd[0] == '\\') {
+			if ((parser->rd[1] == '\n') || (parser->rd[1] == '\0'))
+				break;
+
+			parser->rd++;
+			*token++ = *parser->rd++;
+
+		} else if (*parser->rd == '"' ) {
+			char ch;
+
+			/* Double-quoted string deserve special processing because macros are not expanded
+				inside. We also remove the double quotes. */
+			parser->rd++;
+			while ((*parser->rd != '\0') && (*parser->rd != '\n')) {
+				ch = *parser->rd++;
+				if (ch == '\\') {
+					if ((*parser->rd == '\0') || (*parser->rd == '\n'))
+						break;
+					*token++ = *parser->rd++;
+				} else if (ch == '"')
+					goto found_end_dquote;
+				else
+					*token++ = ch;
+			}
+
+			WMenuParserError(parser, _("missing closing double-quote before end-of-line") );
+
+found_end_dquote:
+			;
+
+		} else if (*parser->rd == '\'') {
+			char ch;
+
+			/* Simple-quoted string deserve special processing because we keep their content
+				as-is, including the quotes and the \-escaped text */
+			*token++ = *parser->rd++;
+			while ((*parser->rd != '\0') && (*parser->rd != '\n')) {
+				ch = *parser->rd++;
+				*token++ = ch;
+				if (ch == '\'')
+					goto found_end_squote;
+			}
+
+			WMenuParserError(parser, _("missing closing simple-quote before end-of-line") );
+
+found_end_squote:
+			;
+
+		} else if (isnamechr(*parser->rd)) {
+			WParserMacro *macro;
+
+			macro = menu_parser_find_macro(parser, parser->rd);
+			if (macro != NULL) {
+				/* The expansion is done inside the parser's buffer
+					this is needed to allow sub macro calls */
+				menu_parser_expand_macro(parser, macro);
+
+				/* Restart parsing to allow expansion of sub macro calls */
+				if (limit-- > 0)
+					goto restart_token_split;
+
+				WMenuParserError(parser, _("too many nested macro expansions, breaking loop"));
+
+				while (isnamechr(*parser->rd))
+					parser->rd++;
+
+				break;
+			} else {
+				while (isnamechr(*parser->rd))
+					*token++ = *parser->rd++;
+			}
+		} else {
+			*token++ = *parser->rd++;
+		}
+
+	*token++ = '\0';
+	token = wmalloc(token - buffer_token);
+	strcpy(token, buffer_token);
+
+	return token;
+}
+
+/* Processing of special # directives */
+static void menu_parser_get_directive(WMenuParser parser)
+{
+	char *command;
+
+	/* Isolate the command */
+	while (isspace(*parser->rd))
+		parser->rd++;
+
+	command = parser->rd;
+	while (*parser->rd)
+		if (isspace(*parser->rd)) {
+			*parser->rd++ = '\0';
+			break;
+		} else {
+			parser->rd++;
+		}
+
+	if (strcmp(command, "include") == 0) {
+		if (!menu_parser_include_file(parser))
+			return;
+
+	} else if (strcmp(command, "define") == 0) {
+		menu_parser_define_macro(parser);
+
+	} else if (strcmp(command, "ifdef") == 0) {
+		menu_parser_condition_ifmacro(parser, 1);
+
+	} else if (strcmp(command, "ifndef") == 0) {
+		menu_parser_condition_ifmacro(parser, 0);
+
+	} else if (strcmp(command, "else") == 0) {
+		menu_parser_condition_else(parser);
+
+	} else if (strcmp(command, "endif") == 0) {
+		menu_parser_condition_end(parser);
+
+	} else {
+		WMenuParserError(parser, _("unknown directive '#%s'"), command);
+		return;
+	}
+
+	if (menu_parser_skip_spaces_and_comments(parser))
+		WMenuParserError(parser, _("extra text after '#' command is ignored: \"%.16s...\""),
+				 parser->rd);
+}
+
+/* Extract the file name, search for it in known directories
+ * and create a sub-parser to handle it.
+ * Returns False if the file could not be found */
+static Bool menu_parser_include_file(WMenuParser parser)
+{
+	char buffer[MAXLINE];
+	char *req_filename, *fullfilename, *p;
+	char eot;
+	FILE *fh;
+
+	if (!menu_parser_skip_spaces_and_comments(parser)) {
+		WMenuParserError(parser, _("no file name found for #include") );
+		return False;
+	}
+
+	switch (*parser->rd++) {
+	case '<':
+		eot = '>';
+		break;
+	case '"':
+		eot = '"';
+		break;
+	default:
+		WMenuParserError(parser, _("file name must be enclosed in brackets or double-quotes for #define") );
+		return False;
+	}
+
+	req_filename = parser->rd;
+	while (*parser->rd) {
+		if (*parser->rd == eot) {
+			*parser->rd++ = '\0';
+			goto found_end_define_fname;
+		} else {
+			parser->rd++;
+		}
+	}
+
+	WMenuParserError(parser, _("missing closing '%c' in filename specification"), eot);
+	return False;
+
+found_end_define_fname:
+	/* If we're inside a #if sequence, we abort now, but not sooner in
+	 * order to keep the syntax check */
+	if (parser->cond.stack[0].skip)
+		return False;
+
+	{ /* Check we are not nesting too many includes */
+		WMenuParser p;
+		int count;
+
+		count = 0;
+		for (p = parser; p->parent_file; p = p->parent_file)
+			count++;
+
+		if (count > MAX_NESTED_INCLUDES) {
+			WMenuParserError(parser, _("too many nested #include's"));
+			return False;
+		}
+	}
+
+	/* Absolute paths */
+	fullfilename = req_filename;
+	if (req_filename[0] != '/') {
+		/* Search first in the same directory as the current file */
+		p = strrchr(parser->file_name, '/');
+		if (p != NULL) {
+			int len;
+
+			len = p - parser->file_name + 1;
+			if (len > sizeof(buffer) - 1)
+				len = sizeof(buffer) - 1;
+
+			strncpy(buffer, parser->file_name, len);
+			strncpy(buffer+len, req_filename, sizeof(buffer) - len - 1);
+			buffer[sizeof(buffer) - 1] = '\0';
+			fullfilename = buffer;
+		}
+	}
+	fh = fopen(fullfilename, "rb");
+
+	/* Not found? Search in wmaker's known places */
+	if (fh == NULL) {
+		if (req_filename[0] != '/') {
+			const char *src;
+			int idx;
+
+			fullfilename = buffer;
+			src = parser->include_default_paths;
+			while (*src != '\0') {
+				idx = 0;
+				if (*src == '~') {
+					const char *home = wgethomedir();
+					while (*home != '\0') {
+						if (idx < sizeof(buffer) - 2)
+							buffer[idx++] = *home;
+						home++;
+					}
+					src++;
+				}
+
+				while ((*src != '\0') && (*src != ':')) {
+					if (idx < sizeof(buffer) - 2)
+						buffer[idx++] = *src;
+					src++;
+				}
+
+				buffer[idx++] = '/';
+				for (p = req_filename; *p != '\0'; p++)
+					if (idx < sizeof(buffer) - 1)
+						buffer[idx++] = *p;
+				buffer[idx] = '\0';
+
+				fh = fopen(fullfilename, "rb");
+				if (fh != NULL)
+					goto found_valid_file;
+
+				if (*src == ':')
+					src++;
+			}
+		}
+		WMenuParserError(parser, _("could not find file \"%s\" for #include"), req_filename);
+		return False;
+	}
+
+	/* Found the file, make it our new source */
+found_valid_file:
+	parser->include_file = menu_parser_create_new(wstrdup(req_filename), fh, parser->include_default_paths);
+	parser->include_file->parent_file = parser;
+	return True;
+}
+
+/* Check wether a macro exists or not, and marks the parser to ignore the
+ * following data accordingly */
+static void menu_parser_condition_ifmacro(WMenuParser parser, Bool check_exists)
+{
+	WParserMacro *macro;
+	int idx;
+	const char *cmd_name, *macro_name;
+
+	cmd_name = check_exists?"ifdef":"ifndef";
+	if (!menu_parser_skip_spaces_and_comments(parser)) {
+		WMenuParserError(parser, _("missing macro name argument to #%s"), cmd_name);
+		return;
+	}
+
+	/* jump to end of provided name for later checks that no extra stuff is following */
+	macro_name = parser->rd;
+	while (isnamechr(*parser->rd))
+		parser->rd++;
+
+	/* Add this condition to the stack of conditions */
+	if (parser->cond.depth >= wlengthof(parser->cond.stack)) {
+		WMenuParserError(parser, _("too many nested #if sequences") );
+		return;
+	}
+
+	for (idx = parser->cond.depth - 1; idx >= 0; idx--)
+		parser->cond.stack[idx + 1] = parser->cond.stack[idx];
+
+	parser->cond.depth++;
+
+	if (parser->cond.stack[1].skip) {
+		parser->cond.stack[0].skip = True;
+	} else {
+		macro = menu_parser_find_macro(parser, macro_name);
+		parser->cond.stack[0].skip =
+			((check_exists)  && (macro == NULL)) ||
+			((!check_exists) && (macro != NULL));
+	}
+
+	strncpy(parser->cond.stack[0].name, cmd_name, sizeof(parser->cond.stack[0].name) - 1);
+	parser->cond.stack[0].line = parser->line_number;
+}
+
+/* Swap the 'data ignore' flag because a #else condition was found */
+static void menu_parser_condition_else(WMenuParser parser)
+{
+	if (parser->cond.depth <= 0) {
+		WMenuParserError(parser, _("found #%s but has no matching #if"), "else");
+		return;
+	}
+
+	if ((parser->cond.depth > 1) && (parser->cond.stack[1].skip))
+		/* The containing #if is false, so we continue skipping anyway */
+		parser->cond.stack[0].skip = True;
+	else
+		parser->cond.stack[0].skip = !parser->cond.stack[0].skip;
+}
+
+/* Closes the current conditional, removing it from the stack */
+static void menu_parser_condition_end(WMenuParser parser)
+{
+	int idx;
+
+	if (parser->cond.depth <= 0) {
+		WMenuParserError(parser, _("found #%s but has no matching #if"), "endif");
+		return;
+	}
+
+	if (--parser->cond.depth > 0)
+		for (idx = 0; idx < parser->cond.depth; idx++)
+			parser->cond.stack[idx] = parser->cond.stack[idx + 1];
+	else
+		parser->cond.stack[0].skip = False;
+}

bazel/WINGs/menuparser.h

@@ -0,0 +1,86 @@
+/* menuparser.h
+ *
+ *  Copyright (c) 2012 Christophe Curis
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef _MENUPARSER_H_INCLUDED
+#define _MENUPARSER_H_INCLUDED
+
+/*
+ * This file is not part of WINGs public API
+ *
+ * It defines internal things for the Menu Parser, the public API is
+ * located in WINGs/WUtil.h as usual
+ */
+
+#define MAXLINE              1024
+#define MAX_NESTED_INCLUDES  16  // To avoid infinite includes case
+#define MAX_NESTED_MACROS    24  // To avoid infinite loop inside macro expansions
+#define MAX_MACRO_ARG_COUNT  32  // Limited by design
+
+typedef struct w_parser_macro WParserMacro;
+
+typedef void WParserMacroFunction(WParserMacro *this, WMenuParser parser);
+
+struct w_menu_parser {
+	WMenuParser include_file;
+	WMenuParser parent_file;
+	const char *include_default_paths;
+	const char *file_name;
+	FILE *file_handle;
+	int line_number;
+	WParserMacro *macros;
+	struct {
+		/* Conditional text parsing is implemented using a stack of the
+			skip states for each nested #if */
+		int depth;
+		struct {
+			Bool skip;
+			char name[8];
+			int line;
+		} stack[32];
+	} cond;
+	char *rd;
+	char line_buffer[MAXLINE];
+};
+
+struct w_parser_macro {
+	WParserMacro *next;
+	char name[64];
+	WParserMacroFunction *function;
+	int arg_count;
+#ifdef DEBUG
+	int usage_count;
+#endif
+	unsigned char value[MAXLINE * 4];
+};
+
+Bool menu_parser_skip_spaces_and_comments(WMenuParser parser);
+
+void menu_parser_register_preset_macros(WMenuParser parser);
+
+void menu_parser_define_macro(WMenuParser parser);
+
+void menu_parser_free_macros(WMenuParser parser);
+
+WParserMacro *menu_parser_find_macro(WMenuParser parser, const char *name);
+
+void menu_parser_expand_macro(WMenuParser parser, WParserMacro *macro);
+
+int isnamechr(char ch); // Check if char is valid character for a macro name
+
+#endif /* _MENUPARSER_H_INCLUDED */

bazel/WINGs/menuparser_macros.c

@@ -0,0 +1,723 @@
+/*
+ *  Window Maker window manager
+ *
+ *  Copyright (c) 2012 Christophe Curis
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "wconfig.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <pwd.h>
+
+#include "WINGs/WUtil.h"
+
+#include "menuparser.h"
+
+/*
+ This file contains the functions related to macros:
+  - parse a macro being defined
+  - handle single macro expansion
+  - pre-defined parser's macros
+
+ Some design notes for macro internal storage:
+
+ arg_count is -1 when the macro does not take arguments
+   but 0 when no args but still using parenthesis. The
+   difference is explained in GNU cpp's documentation:
+ http://gcc.gnu.org/onlinedocs/cpp/Function_002dlike-Macros.html
+
+ the value is stored for fast expansion; here is an
+   example of the storage format used:
+ #define EXAMPLE(a, b)  "text:" a and b!
+   will be stored in macro->value[] as:
+ 0x0000: 0x00 0x07       (strlen(part 1))
+ 0x0002: '"', 't', 'e', 'x', 't', ':', '"'   (first part)
+ 0x0009: 0x00            (part 2, id=0 for replacement by 1st parameter 'a')
+ 0x000A: 0x00 0x03       (strlen(part 3))
+ 0x000C: 'a', 'n', 'd'   (part 3)
+ 0x000F: 0x01            (part 4, id=1 for replacement by 2nd parameter 'b')
+ 0x0010: 0x00 0x01       (strlen(part 5))
+ 0x0012: '!'             (part 5)
+ 0x0013: 0xFF            (end of macro)
+  This structure allows to store any number and combination
+   of text/parameter and still provide very fast generation
+   at macro replacement time.
+
+ Predefined macros are using a call-back function mechanism
+   to generate the value on-demand. This value is generated
+   in the 'value' buffer of the structure.
+ Most of these call-backs will actually cache the value:
+   they generate it on the first use (inside a parser,
+   not globally) and reuse that value on next call(s).
+
+ Because none of these macros take parameters, the call-back
+   mechanism does not include passing of user arguments; the
+   complex storage mechanism for argument replacement being
+   not necessary the macro->value parameter is used as a
+   plain C string to be copied, this fact being recognised
+   by macro->function being non-null. It was chosen that the
+   call-back function would not have the possibility to fail.
+*/
+
+static Bool menu_parser_read_macro_def(WMenuParser parser, WParserMacro *macro, char **argname);
+
+static Bool menu_parser_read_macro_args(WMenuParser parser, WParserMacro *macro,
+                                        char *array[], char *buffer, ssize_t buffer_size);
+
+/* Free all used memory associated with parser's macros */
+void menu_parser_free_macros(WMenuParser parser)
+{
+	WParserMacro *macro, *mnext;
+#ifdef DEBUG
+	unsigned char *rd;
+	unsigned int size;
+	unsigned int count;
+
+	/* if we were compiled with debugging, we take the opportunity that we
+		parse the list of macros, for memory release, to print all the
+		definitions */
+	printf(__FILE__ ": Macros defined while parsing \"%s\"\n", parser->file_name);
+	count = 0;
+#endif
+	for (macro = parser->macros; macro != NULL; macro = mnext) {
+#ifdef DEBUG
+		printf("  %s", macro->name);
+		if (macro->arg_count >= 0)
+			printf("(args=%d)", macro->arg_count);
+		printf(" = ");
+
+		if (macro->function != NULL) {
+			macro->function(macro, parser);
+			printf("function:\"%s\"", macro->value);
+		} else {
+			rd = macro->value;
+			for (;;) {
+				putchar('"');
+				size  = (*rd++) << 8;
+				size |=  *rd++;
+				while (size-- > 0) putchar(*rd++);
+				putchar('"');
+				if (*rd == 0xFF) break;
+				printf(" #%d ", (*rd++) + 1);
+			}
+		}
+		printf(", used %d times\n", macro->usage_count);
+		count++;
+#endif
+		mnext = macro->next;
+		wfree(macro);
+	}
+#ifdef DEBUG
+	printf(__FILE__ ": %d macros\n", count);
+#endif
+	parser->macros = NULL; // Security
+}
+
+/* Check wether the specified character is valid for a name (macro, parameter) or not */
+int isnamechr(char ch)
+{
+	static const int table[256] = {
+		[0] = 0, // In case we'd fall on buggy compiler, to avoid crash
+		// C99: 6.7.8.21 -> non specified values are initialised to 0
+		['0'] = 1, ['1'] = 1, ['2'] = 1, ['3'] = 1, ['4'] = 1,
+		['5'] = 1, ['6'] = 1, ['7'] = 1, ['8'] = 1, ['9'] = 1,
+		['A'] = 1, ['B'] = 1, ['C'] = 1, ['D'] = 1, ['E'] = 1, ['F'] = 1,
+		['G'] = 1, ['H'] = 1, ['I'] = 1, ['J'] = 1, ['K'] = 1, ['L'] = 1,
+		['M'] = 1, ['N'] = 1, ['O'] = 1, ['P'] = 1, ['Q'] = 1, ['R'] = 1,
+		['S'] = 1, ['T'] = 1, ['U'] = 1, ['V'] = 1, ['W'] = 1, ['X'] = 1,
+		['Y'] = 1, ['Z'] = 1,
+		['a'] = 1, ['b'] = 1, ['c'] = 1, ['d'] = 1, ['e'] = 1, ['f'] = 1,
+		['g'] = 1, ['h'] = 1, ['i'] = 1, ['j'] = 1, ['k'] = 1, ['l'] = 1,
+		['m'] = 1, ['n'] = 1, ['o'] = 1, ['p'] = 1, ['q'] = 1, ['r'] = 1,
+		['s'] = 1, ['t'] = 1, ['u'] = 1, ['v'] = 1, ['w'] = 1, ['x'] = 1,
+		['y'] = 1, ['z'] = 1,
+		['_'] = 1
+		// We refuse any UTF-8 coded character, or accents in ISO-xxx codepages
+	};
+	return table[0x00FF & (unsigned)ch ];
+}
+
+/* Parse the definition of the macro and add it to the top-most parser's list */
+void menu_parser_define_macro(WMenuParser parser)
+{
+	WParserMacro *macro;
+	int idx;
+	char arg_names_buf[MAXLINE];
+	char *arg_name[MAX_MACRO_ARG_COUNT];
+
+	if (!menu_parser_skip_spaces_and_comments(parser)) {
+		WMenuParserError(parser, _("no macro name found for #define") );
+		return;
+	}
+	macro = wmalloc(sizeof(*macro));
+	memset(arg_name, 0, MAX_MACRO_ARG_COUNT * sizeof(char *));
+
+	/* Isolate name of macro */
+	idx = 0;
+	while (isnamechr(*parser->rd)) {
+		if (idx < sizeof(macro->name) - 1)
+			macro->name[idx++] = *parser->rd;
+		parser->rd++;
+	}
+	// macro->name[idx] = '\0'; -> Already present because wmalloc filled struct with 0s
+
+	/* Build list of expected arguments */
+	if (*parser->rd == '(') {
+		parser->rd++;
+		idx = 0;
+		for (;;) {
+			if (!menu_parser_skip_spaces_and_comments(parser)) {
+			arglist_error_premature_eol:
+				WMenuParserError(parser, _("premature end of file while reading arg-list for macro \"%s\""), macro->name);
+				wfree(macro);
+				return;
+			}
+			if (*parser->rd == ')') break;
+
+			if (macro->arg_count >= wlengthof(arg_name)) {
+				WMenuParserError(parser, _("too many parameters for macro \"%s\" definition"), macro->name);
+				wfree(macro);
+				*parser->rd = '\0'; // fake end-of-line to avoid warnings from remaining line content
+				return;
+			}
+			if (isnamechr(*parser->rd)) {
+				arg_name[macro->arg_count++] = arg_names_buf + idx;
+				do {
+					if (idx < sizeof(arg_names_buf) - 1)
+						arg_names_buf[idx++] = *parser->rd;
+					parser->rd++;
+				} while (isnamechr(*parser->rd));
+				arg_names_buf[idx] = '\0';
+				if (idx < sizeof(arg_names_buf) - 1) idx++;
+			} else {
+				WMenuParserError(parser, _("invalid character '%c' in arg-list for macro \"%s\" while expecting parameter name"),
+									  *parser->rd, macro->name);
+				wfree(macro);
+				*parser->rd = '\0'; // fake end-of-line to avoid warnings from remaining line content
+				return;
+			}
+			if (!menu_parser_skip_spaces_and_comments(parser))
+				goto arglist_error_premature_eol;
+			if (*parser->rd == ')') break;
+
+			if (*parser->rd != ',') {
+				WMenuParserError(parser, _("invalid character '%c' in arg-list for macro \"%s\" while expecting ',' or ')'"),
+									  *parser->rd, macro->name);
+				wfree(macro);
+				*parser->rd = '\0'; // fake end-of-line to avoid warnings from remaining line content
+				return;
+			}
+			parser->rd++;
+		}
+		parser->rd++;  // skip the closing ')'
+	} else
+		macro->arg_count = -1; // Means no parenthesis at all to expect
+
+	/* If we're inside a #if sequence, we abort now, but not sooner in
+		order to keep the syntax check */
+	if (parser->cond.stack[0].skip) {
+		wfree(macro);
+		*parser->rd = '\0'; // Ignore macro content
+		return;
+	}
+
+	/* Get the macro's definition */
+	menu_parser_skip_spaces_and_comments(parser);
+	if (!menu_parser_read_macro_def(parser, macro, arg_name)) {
+		wfree(macro);
+		return;
+	}
+
+	/* Create the macro in the Root parser */
+	while (parser->parent_file != NULL)
+		parser = parser->parent_file;
+
+	/* Check that the macro was not already defined */
+	if (menu_parser_find_macro(parser, macro->name) != NULL) {
+		WMenuParserError(parser, _("macro \"%s\" already defined, ignoring redefinition"),
+							  macro->name);
+		wfree(macro);
+		return;
+	}
+
+	/* Append at beginning of list */
+	macro->next = parser->macros;
+	parser->macros = macro;
+}
+
+/* Check if the current word in the parser matches a macro */
+WParserMacro *menu_parser_find_macro(WMenuParser parser, const char *name)
+{
+	const char *ref, *cmp;
+	WParserMacro *macro;
+
+	while (parser->parent_file != NULL)
+		parser = parser->parent_file;
+	for (macro = parser->macros; macro != NULL; macro = macro->next) {
+		ref = macro->name;
+		cmp = name;
+		while (*ref != '\0')
+			if (*ref++ != *cmp++)
+				goto check_next_macro;
+		if (isnamechr(*cmp))
+			continue;
+
+		return macro;
+	check_next_macro:
+		;
+	}
+	return NULL;
+}
+
+/* look to see if the next word matches the name of one of the parameter
+	names for a macro definition
+	This function is internal to the macro definition function as this is
+	where the analysis is done */
+static inline char *mp_is_parameter(char *parse, const char *param) {
+	while (*param)
+		if (*parse++ != *param++)
+			return NULL;
+	if (isnamechr(*parse))
+		return NULL;
+	return parse;
+}
+
+/* Read the content definition part of a #define construct (the part after the optional
+	argument list) and store it in the prepared format for quick expansion
+
+	There is no need to keep track of the names of the parameters, so they are stored in
+	a temporary storage for the time of the macro parsing. */
+static Bool menu_parser_read_macro_def(WMenuParser parser, WParserMacro *macro, char **arg)
+{
+	unsigned char *wr_size;
+	unsigned char *wr;
+	unsigned int size_data;
+	unsigned int size_max;
+	int i;
+
+	wr_size = macro->value;
+	size_data = 0;
+	wr = wr_size + 2;
+	size_max = sizeof(macro->value) - (wr - macro->value) - 3;
+	while (menu_parser_skip_spaces_and_comments(parser)) {
+		if (isnamechr(*parser->rd)) {
+			char *next_rd;
+
+			/* Is the current word a parameter to replace? */
+			for (i = 0; i < macro->arg_count; i++) {
+				next_rd = mp_is_parameter(parser->rd, arg[i]);
+				if (next_rd != NULL) {
+					if (wr + 4 >= macro->value + sizeof(macro->value))
+						goto error_too_much_data;
+					wr_size[0] = (size_data >> 8) & 0xFF;
+					wr_size[1] =  size_data       & 0xFF;
+					*wr++ = i;
+					wr_size = wr;
+					wr += 2;
+					parser->rd = next_rd;
+					*wr++ = ' ';
+					size_data = 1;
+					size_max = sizeof(macro->value) - (wr - macro->value) - 3;
+					goto next_loop; // Because we can't 'break' this loop and 'continue'
+					//                 the outer one in a clean and easy way
+				}
+			}
+
+			/* Not parameter name -> copy as-is */
+			do {
+				*wr++ = *parser->rd++;
+				if (++size_data >= size_max) {
+				error_too_much_data:
+					WMenuParserError(parser, _("more content than supported for the macro \"%s\""),
+										  macro->name);
+					return False;
+				}
+			} while (isnamechr(*parser->rd));
+			if (isspace(*parser->rd)) {
+				*wr++ = ' ';
+				if (++size_data >= size_max)
+					goto error_too_much_data;
+			}
+		} else {
+			/* Some uninterresting characters, copy as-is */
+			while (*parser->rd != '\0') {
+				if (isnamechr(*parser->rd)) break; // handle in next loop
+				if (parser->rd[0] == '/')
+					if ((parser->rd[1] == '*') || (parser->rd[1] == '/'))
+						break; // Comments are handled by std function
+				if ((parser->rd[0] == '\\') &&
+					 (parser->rd[1] == '\n') &&
+					 (parser->rd[2] == '\0'))
+					break; // Long-lines are handled by std function
+				*wr++ = *parser->rd++;
+				if (++size_data >= size_max)
+					goto error_too_much_data;
+			}
+		}
+	next_loop:
+		;
+	}
+	wr_size[0] = (size_data >> 8) & 0xFF;
+	wr_size[1] =  size_data       & 0xFF;
+	*wr = 0xFF;
+	return True;
+}
+
+/* When a macro is being used in the file, this function will generate the
+	expanded value for the macro in the parser's work line.
+	It blindly supposes that the data generated in macro->value is valid */
+void menu_parser_expand_macro(WMenuParser parser, WParserMacro *macro)
+{
+	char save_buf[sizeof(parser->line_buffer)];
+	char arg_values_buf[MAXLINE];
+	char *arg_value[MAX_MACRO_ARG_COUNT];
+	char *src, *dst;
+	unsigned char *rd;
+	unsigned int size;
+	int i, space_left;
+
+	memset(arg_value, 0, MAX_MACRO_ARG_COUNT * sizeof(char *));
+
+	/* Skip the name of the macro, this was not done by caller */
+	for (i = 0; macro->name[i] != '\0'; i++)
+		parser->rd++;
+
+	if (macro->arg_count >= 0) {
+		menu_parser_skip_spaces_and_comments(parser);
+		if (!menu_parser_read_macro_args(parser, macro, arg_value, arg_values_buf, sizeof(arg_values_buf)))
+			return;
+	}
+
+#ifdef DEBUG
+	macro->usage_count++;
+#endif
+
+	/* Save the remaining data from current line as we will overwrite the
+		current line's workspace with the expanded macro, so we can re-append
+		it afterwards */
+	dst = save_buf;
+	while ((*dst++ = *parser->rd++) != '\0') ;
+
+	/* Generate expanded macro */
+	dst = parser->line_buffer;
+	parser->rd = dst;
+	space_left = sizeof(parser->line_buffer) - 1;
+	if (macro->function != NULL) {
+        /* Parser's pre-defined macros actually proposes a function call to
+			  generate dynamic value for the expansion of the macro. In this case
+			  it is generated as a C string in the macro->value and used directly */
+		macro->function(macro, parser);
+		rd = macro->value;
+		while (--space_left > 0)
+			if ((*dst = *rd++) == '\0')
+				break;
+			else
+				dst++;
+	} else {
+		rd = macro->value;
+		for (;;) {
+			size  = (*rd++) << 8;
+			size |=  *rd++;
+			while (size-- > 0) {
+				*dst = *rd++;
+				if (--space_left > 0) dst++;
+			}
+			if (*rd == 0xFF) break;
+			src = arg_value[*rd++];
+			while (*src) {
+				*dst = *src++;
+				if (--space_left > 0) dst++;
+			}
+		}
+	}
+
+	/* Copy finished -> Re-append the text that was following the macro */
+	src = save_buf;
+	while (--space_left > 0)
+		if ((*dst++ = *src++) == '\0')
+			break;
+	*dst = '\0';
+
+	if (space_left <= 0)
+		WMenuParserError(parser, _("expansion for macro \"%s\" too big, line truncated"),
+							  macro->name);
+}
+
+/* When reading a macro to be expanded (not being defined), that takes arguments,
+	this function parses the arguments being provided */
+static Bool menu_parser_read_macro_args(WMenuParser parser, WParserMacro *macro,
+													 char *array[], char *buffer, ssize_t buffer_size)
+{
+	int arg;
+
+	if (*parser->rd != '(') {
+		WMenuParserError(parser, _("macro \"%s\" needs parenthesis for arguments"),
+							  macro->name);
+		return False;
+	}
+	parser->rd++;
+
+	buffer_size--; // Room for final '\0'
+	menu_parser_skip_spaces_and_comments(parser);
+	arg = 0;
+	for (;;) {
+		int paren_count;
+
+		array[arg] = buffer;
+		paren_count = 0;
+		while (*parser->rd != '\0') {
+
+			if (*parser->rd == '(')
+				paren_count++;
+
+			if (paren_count <= 0)
+				if ((*parser->rd == ',') ||
+					 (*parser->rd == ')') ) break;
+
+			if ((*parser->rd == '"') || (*parser->rd == '\'')) {
+				char eot = *parser->rd++;
+				if (buffer_size-- > 0) *buffer++ = eot;
+				while (*parser->rd) {
+					if ((*buffer = *parser->rd++) == eot)
+						goto found_end_of_string;
+					if (buffer_size-- > 0) buffer++;
+				}
+				WMenuParserError(parser, _("missing closing quote or double-quote before end-of-line") );
+				return False;
+			found_end_of_string:
+				continue;
+			}
+
+			if (isspace(*parser->rd)) {
+				if (buffer_size-- > 0) *buffer++ = ' ';
+				menu_parser_skip_spaces_and_comments(parser);
+				continue;
+			}
+
+			*buffer = *parser->rd++;
+			if (buffer_size-- > 0) buffer++;
+		}
+		*buffer = '\0';
+		if (buffer_size-- > 0) buffer++;
+
+		arg++;
+
+		if (*parser->rd == ',') {
+			parser->rd++;
+			if (arg >= macro->arg_count) {
+				WMenuParserError(parser, _("too many arguments for macro \"%s\", expected only %d"),
+									  macro->name, macro->arg_count);
+				return False;
+			}
+			continue;
+		}
+		break;
+	}
+	if (*parser->rd != ')') {
+		WMenuParserError(parser, _("premature end of line while searching for arguments to macro \"%s\""),
+							  macro->name);
+		return False;
+	}
+	parser->rd++;
+	if (arg < macro->arg_count) {
+		WMenuParserError(parser, _("not enough arguments for macro \"%s\", expected %d but got only %d"),
+							  macro->name, macro->arg_count, arg);
+		return False;
+	}
+	if (buffer_size < 0)
+		WMenuParserError(parser, _("too much data in parameter list of macro \"%s\", truncated"),
+							  macro->name);
+	return True;
+}
+
+/******************************************************************************/
+/* Definition of pre-defined macros */
+/******************************************************************************/
+
+void WMenuParserRegisterSimpleMacro(WMenuParser parser, const char *name, const char *value)
+{
+	WParserMacro *macro;
+	size_t len;
+	unsigned char *wr;
+
+	macro = wmalloc(sizeof(*macro));
+	strncpy(macro->name, name, sizeof(macro->name)-1);
+	macro->arg_count = -1;
+	len = strlen(value);
+	if (len > sizeof(macro->value) - 3) {
+		wwarning(_("size of value for macro '%s' is too big, truncated"), name);
+		len = sizeof(macro->value) - 3;
+	}
+	macro->value[0] = (len >> 8) & 0xFF;
+	macro->value[1] =  len       & 0xFF;
+	wr = &macro->value[2];
+	while (len-- > 0)
+		*wr++ = *value++;
+	*wr = 0xFF;
+	macro->next = parser->macros;
+	parser->macros = macro;
+}
+
+/* Name of the originally loaded file (before #includes) */
+static void mpm_base_file(WParserMacro *this, WMenuParser parser)
+{
+	unsigned char *src, *dst;
+
+	if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
+
+	while (parser->parent_file != NULL)
+		parser = parser->parent_file;
+
+	dst = this->value;
+	src = (unsigned char *) parser->file_name;
+	*dst++ = '\"';
+	while (*src != '\0')
+		if (dst < this->value + sizeof(this->value) - 2)
+			*dst++ = *src++;
+		else
+			break;
+	*dst++ = '\"';
+	*dst   = '\0';
+}
+
+/* Number of #include currently nested */
+static void mpm_include_level(WParserMacro *this, WMenuParser parser)
+{
+	int level = 0;
+	while (parser->parent_file != NULL) {
+		parser = parser->parent_file;
+		level++;
+	}
+	snprintf((char *) this->value, sizeof(this->value), "%d", level);
+}
+
+/* Name of current file */
+static void mpm_current_file(WParserMacro *this, WMenuParser parser)
+{
+	unsigned char *src, *dst;
+
+	dst = this->value;
+	src = (unsigned char *) parser->file_name;
+	*dst++ = '\"';
+	while (*src != '\0')
+		if (dst < this->value + sizeof(this->value) - 2)
+			*dst++ = *src++;
+		else
+			break;
+	*dst++ = '\"';
+	*dst   = '\0';
+}
+
+/* Number of current line */
+static void mpm_current_line(WParserMacro *this, WMenuParser parser)
+{
+	snprintf((char *) this->value, sizeof(this->value), "%d", parser->line_number);
+}
+
+/* Name of host on which we are running, not necessarily displaying */
+static void mpm_get_hostname(WParserMacro *this, WMenuParser parser)
+{
+	char *h;
+
+	if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
+
+	h = getenv("HOSTNAME");
+	if (h == NULL) {
+		h = getenv("HOST");
+		if (h == NULL) {
+			if (gethostname((char *) this->value, sizeof(this->value) ) != 0) {
+				WMenuParserError(parser, _("could not determine %s"), "HOSTNAME");
+				this->value[0] = '?';
+				this->value[1] = '?';
+				this->value[2] = '?';
+				this->value[3] = '\0';
+			}
+			return;
+		}
+	}
+	wstrlcpy((char *) this->value, h, sizeof(this->value) );
+}
+
+/* Name of the current user */
+static void mpm_get_user_name(WParserMacro *this, WMenuParser parser)
+{
+	char *user;
+
+	if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
+
+	user = getlogin();
+	if (user == NULL) {
+		struct passwd *pw_user;
+
+		pw_user = getpwuid(getuid());
+		if (pw_user == NULL) {
+		error_no_username:
+			WMenuParserError(parser, _("could not determine %s"), "USER" );
+			/* Fall back on numeric id - better than nothing */
+			snprintf((char *) this->value, sizeof(this->value), "%d", getuid() );
+			return;
+		}
+		user = pw_user->pw_name;
+		if (user == NULL) goto error_no_username;
+	}
+	wstrlcpy((char *) this->value, user, sizeof(this->value) );
+}
+
+/* Number id of the user under which we are running */
+static void mpm_get_user_id(WParserMacro *this, WMenuParser parser)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) parser;
+
+	if (this->value[0] != '\0') return; // Already evaluated, re-use previous
+	snprintf((char *) this->value, sizeof(this->value), "%d", getuid() );
+}
+
+/* Small helper to automate creation of one pre-defined macro in the parser */
+static void w_create_macro(WMenuParser parser, const char *name, WParserMacroFunction *handler)
+{
+	WParserMacro *macro;
+
+	macro = wmalloc(sizeof(*macro));
+	strncpy(macro->name, name, sizeof(macro->name) - 1);
+	macro->function = handler;
+	macro->arg_count = -1;
+	macro->next = parser->macros;
+	parser->macros = macro;
+}
+
+/***** Register all the pre-defined macros in the parser *****/
+void menu_parser_register_preset_macros(WMenuParser parser)
+{
+	/* Defined by CPP: common predefined macros (GNU C extension) */
+	w_create_macro(parser, "__BASE_FILE__", mpm_base_file);
+	w_create_macro(parser, "__INCLUDE_LEVEL__", mpm_include_level);
+
+	/* Defined by CPP: standard predefined macros */
+	w_create_macro(parser, "__FILE__", mpm_current_file);
+	w_create_macro(parser, "__LINE__", mpm_current_line);
+	// w_create_macro(parser, "__DATE__", NULL);  [will be implemented only per user request]
+	// w_create_macro(parser, "__TIME__", NULL);  [will be implemented only per user request]
+
+	/* Historically defined by WindowMaker */
+	w_create_macro(parser, "HOST", mpm_get_hostname);
+	w_create_macro(parser, "UID", mpm_get_user_id);
+	w_create_macro(parser, "USER", mpm_get_user_name);
+}

bazel/WINGs/misc.c

@@ -0,0 +1,45 @@
+/* WUtil / misc.c
+ *
+ *  Copyright (c) 2001 Dan Pascu
+ *  Copyright (c) 2014 Window Maker Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* Miscelaneous helper functions */
+
+#include "WINGs/WUtil.h"
+
+#include "error.h"
+
+WMRange wmkrange(int start, int count)
+{
+	WMRange range;
+
+	range.position = start;
+	range.count = count;
+
+	return range;
+}
+
+/*
+ * wutil_shutdown - cleanup in WUtil when user program wants to exit
+ */
+void wutil_shutdown(void)
+{
+#ifdef HAVE_SYSLOG
+	w_syslog_close();
+#endif
+}

bazel/WINGs/notification.c

@@ -0,0 +1,482 @@
+
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "WINGs/WUtil.h"
+#include "WINGs/WINGsP.h"
+
+
+typedef struct W_Notification {
+	const char *name;
+	void *object;
+	void *clientData;
+	int refCount;
+} Notification;
+
+
+const char *WMGetNotificationName(WMNotification * notification)
+{
+	return notification->name;
+}
+
+void *WMGetNotificationObject(WMNotification * notification)
+{
+	return notification->object;
+}
+
+void *WMGetNotificationClientData(WMNotification * notification)
+{
+	return notification->clientData;
+}
+
+WMNotification *WMCreateNotification(const char *name, void *object, void *clientData)
+{
+	Notification *nPtr;
+
+	nPtr = wmalloc(sizeof(Notification));
+	nPtr->name = name;
+	nPtr->object = object;
+	nPtr->clientData = clientData;
+	nPtr->refCount = 1;
+
+	return nPtr;
+}
+
+void WMReleaseNotification(WMNotification * notification)
+{
+	notification->refCount--;
+
+	if (notification->refCount < 1) {
+		wfree(notification);
+	}
+}
+
+WMNotification *WMRetainNotification(WMNotification * notification)
+{
+	notification->refCount++;
+
+	return notification;
+}
+
+/***************** Notification Center *****************/
+
+typedef struct NotificationObserver {
+	WMNotificationObserverAction *observerAction;
+	void *observer;
+
+	const char *name;
+	void *object;
+
+	struct NotificationObserver *prev;	/* for tables */
+	struct NotificationObserver *next;
+	struct NotificationObserver *nextAction;	/* for observerTable */
+} NotificationObserver;
+
+typedef struct W_NotificationCenter {
+	WMHashTable *nameTable;	/* names -> observer lists */
+	WMHashTable *objectTable;	/* object -> observer lists */
+	NotificationObserver *nilList;	/* obervers that catch everything */
+
+	WMHashTable *observerTable;	/* observer -> NotificationObserver */
+} NotificationCenter;
+
+/* default (and only) center */
+static NotificationCenter *notificationCenter = NULL;
+
+void W_InitNotificationCenter(void)
+{
+	notificationCenter = wmalloc(sizeof(NotificationCenter));
+	notificationCenter->nameTable = WMCreateHashTable(WMStringPointerHashCallbacks);
+	notificationCenter->objectTable = WMCreateHashTable(WMIntHashCallbacks);
+	notificationCenter->nilList = NULL;
+	notificationCenter->observerTable = WMCreateHashTable(WMIntHashCallbacks);
+}
+
+void W_ReleaseNotificationCenter(void)
+{
+	if (notificationCenter) {
+		if (notificationCenter->nameTable)
+			WMFreeHashTable(notificationCenter->nameTable);
+		if (notificationCenter->objectTable)
+			WMFreeHashTable(notificationCenter->objectTable);
+		if (notificationCenter->observerTable)
+			WMFreeHashTable(notificationCenter->observerTable);
+
+		wfree(notificationCenter);
+		notificationCenter = NULL;
+	}
+}
+
+void
+WMAddNotificationObserver(WMNotificationObserverAction * observerAction,
+			  void *observer, const char *name, void *object)
+{
+	NotificationObserver *oRec, *rec;
+
+	oRec = wmalloc(sizeof(NotificationObserver));
+	oRec->observerAction = observerAction;
+	oRec->observer = observer;
+	oRec->name = name;
+	oRec->object = object;
+	oRec->next = NULL;
+	oRec->prev = NULL;
+
+	/* put this action in the list of actions for this observer */
+	rec = (NotificationObserver *) WMHashInsert(notificationCenter->observerTable, observer, oRec);
+
+	if (rec) {
+		/* if this is not the first action for the observer */
+		oRec->nextAction = rec;
+	} else {
+		oRec->nextAction = NULL;
+	}
+
+	if (!name && !object) {
+		/* catch-all */
+		oRec->next = notificationCenter->nilList;
+		if (notificationCenter->nilList) {
+			notificationCenter->nilList->prev = oRec;
+		}
+		notificationCenter->nilList = oRec;
+	} else if (!name) {
+		/* any message coming from object */
+		rec = (NotificationObserver *) WMHashInsert(notificationCenter->objectTable, object, oRec);
+		oRec->next = rec;
+		if (rec) {
+			rec->prev = oRec;
+		}
+	} else {
+		/* name && (object || !object) */
+		rec = (NotificationObserver *) WMHashInsert(notificationCenter->nameTable, name, oRec);
+		oRec->next = rec;
+		if (rec) {
+			rec->prev = oRec;
+		}
+	}
+}
+
+void WMPostNotification(WMNotification * notification)
+{
+	NotificationObserver *orec, *tmp;
+
+	WMRetainNotification(notification);
+
+	/* tell the observers that want to know about a particular message */
+	orec = (NotificationObserver *) WMHashGet(notificationCenter->nameTable, notification->name);
+
+	while (orec) {
+		tmp = orec->next;
+
+		if (!orec->object || !notification->object || orec->object == notification->object) {
+			/* tell the observer */
+			if (orec->observerAction) {
+				(*orec->observerAction) (orec->observer, notification);
+			}
+		}
+
+		orec = tmp;
+	}
+
+	/* tell the observers that want to know about an object */
+	orec = (NotificationObserver *) WMHashGet(notificationCenter->objectTable, notification->object);
+
+	while (orec) {
+		tmp = orec->next;
+
+		/* tell the observer */
+		if (orec->observerAction) {
+			(*orec->observerAction) (orec->observer, notification);
+		}
+		orec = tmp;
+	}
+
+	/* tell the catch all observers */
+	orec = notificationCenter->nilList;
+	while (orec) {
+		tmp = orec->next;
+
+		/* tell the observer */
+		if (orec->observerAction) {
+			(*orec->observerAction) (orec->observer, notification);
+		}
+		orec = tmp;
+	}
+
+	WMReleaseNotification(notification);
+}
+
+void WMRemoveNotificationObserver(void *observer)
+{
+	NotificationObserver *orec, *tmp, *rec;
+
+	/* get the list of actions the observer is doing */
+	orec = (NotificationObserver *) WMHashGet(notificationCenter->observerTable, observer);
+
+	/*
+	 * FOREACH orec IN actionlist for observer
+	 * DO
+	 *   remove from respective lists/tables
+	 *   free
+	 * END
+	 */
+	while (orec) {
+		tmp = orec->nextAction;
+
+		if (!orec->name && !orec->object) {
+			/* catch-all */
+			if (notificationCenter->nilList == orec)
+				notificationCenter->nilList = orec->next;
+		} else if (!orec->name) {
+			/* any message coming from object */
+			rec = (NotificationObserver *) WMHashGet(notificationCenter->objectTable, orec->object);
+			if (rec == orec) {
+				/* replace table entry */
+				if (orec->next) {
+					WMHashInsert(notificationCenter->objectTable, orec->object, orec->next);
+				} else {
+					WMHashRemove(notificationCenter->objectTable, orec->object);
+				}
+			}
+		} else {
+			/* name && (object || !object) */
+			rec = (NotificationObserver *) WMHashGet(notificationCenter->nameTable, orec->name);
+			if (rec == orec) {
+				/* replace table entry */
+				if (orec->next) {
+					WMHashInsert(notificationCenter->nameTable, orec->name, orec->next);
+				} else {
+					WMHashRemove(notificationCenter->nameTable, orec->name);
+				}
+			}
+		}
+		if (orec->prev)
+			orec->prev->next = orec->next;
+		if (orec->next)
+			orec->next->prev = orec->prev;
+
+		wfree(orec);
+
+		orec = tmp;
+	}
+
+	WMHashRemove(notificationCenter->observerTable, observer);
+}
+
+void WMRemoveNotificationObserverWithName(void *observer, const char *name, void *object)
+{
+	NotificationObserver *orec, *tmp, *rec;
+	NotificationObserver *newList = NULL;
+
+	/* get the list of actions the observer is doing */
+	orec = (NotificationObserver *) WMHashGet(notificationCenter->observerTable, observer);
+
+	WMHashRemove(notificationCenter->observerTable, observer);
+
+	/* rebuild the list of actions for the observer */
+
+	while (orec) {
+		tmp = orec->nextAction;
+		if (orec->name == name && orec->object == object) {
+			if (!name && !object) {
+				if (notificationCenter->nilList == orec)
+					notificationCenter->nilList = orec->next;
+			} else if (!name) {
+				rec =
+				    (NotificationObserver *) WMHashGet(notificationCenter->objectTable,
+								       orec->object);
+				if (rec == orec) {
+					assert(rec->prev == NULL);
+					/* replace table entry */
+					if (orec->next) {
+						WMHashInsert(notificationCenter->objectTable,
+							     orec->object, orec->next);
+					} else {
+						WMHashRemove(notificationCenter->objectTable, orec->object);
+					}
+				}
+			} else {
+				rec = (NotificationObserver *) WMHashGet(notificationCenter->nameTable,
+									 orec->name);
+				if (rec == orec) {
+					assert(rec->prev == NULL);
+					/* replace table entry */
+					if (orec->next) {
+						WMHashInsert(notificationCenter->nameTable,
+							     orec->name, orec->next);
+					} else {
+						WMHashRemove(notificationCenter->nameTable, orec->name);
+					}
+				}
+			}
+
+			if (orec->prev)
+				orec->prev->next = orec->next;
+			if (orec->next)
+				orec->next->prev = orec->prev;
+			wfree(orec);
+		} else {
+			/* append this action in the new action list */
+			orec->nextAction = NULL;
+			if (!newList) {
+				newList = orec;
+			} else {
+				NotificationObserver *p;
+
+				p = newList;
+				while (p->nextAction) {
+					p = p->nextAction;
+				}
+				p->nextAction = orec;
+			}
+		}
+		orec = tmp;
+	}
+
+	/* reinsert the list to the table */
+	if (newList) {
+		WMHashInsert(notificationCenter->observerTable, observer, newList);
+	}
+}
+
+void WMPostNotificationName(const char *name, void *object, void *clientData)
+{
+	WMNotification *notification;
+
+	notification = WMCreateNotification(name, object, clientData);
+
+	WMPostNotification(notification);
+
+	WMReleaseNotification(notification);
+}
+
+/**************** Notification Queues ****************/
+
+typedef struct W_NotificationQueue {
+	WMArray *asapQueue;
+	WMArray *idleQueue;
+
+	struct W_NotificationQueue *next;
+} NotificationQueue;
+
+static WMNotificationQueue *notificationQueueList = NULL;
+
+/* default queue */
+static WMNotificationQueue *notificationQueue = NULL;
+
+WMNotificationQueue *WMGetDefaultNotificationQueue(void)
+{
+	if (!notificationQueue)
+		notificationQueue = WMCreateNotificationQueue();
+
+	return notificationQueue;
+}
+
+WMNotificationQueue *WMCreateNotificationQueue(void)
+{
+	NotificationQueue *queue;
+
+	queue = wmalloc(sizeof(NotificationQueue));
+	queue->asapQueue = WMCreateArrayWithDestructor(8, (WMFreeDataProc *) WMReleaseNotification);
+	queue->idleQueue = WMCreateArrayWithDestructor(8, (WMFreeDataProc *) WMReleaseNotification);
+	queue->next = notificationQueueList;
+
+	notificationQueueList = queue;
+
+	return queue;
+}
+
+void WMEnqueueNotification(WMNotificationQueue * queue, WMNotification * notification, WMPostingStyle postingStyle)
+{
+	WMEnqueueCoalesceNotification(queue, notification, postingStyle, WNCOnName | WNCOnSender);
+}
+
+#define NOTIF ((WMNotification*)cdata)
+#define ITEM  ((WMNotification*)item)
+
+static int matchSenderAndName(const void *item, const void *cdata)
+{
+	return (NOTIF->object == ITEM->object && strcmp(NOTIF->name, ITEM->name) == 0);
+}
+
+static int matchSender(const void *item, const void *cdata)
+{
+	return (NOTIF->object == ITEM->object);
+}
+
+static int matchName(const void *item, const void *cdata)
+{
+	return (strcmp(NOTIF->name, ITEM->name) == 0);
+}
+
+#undef NOTIF
+#undef ITEM
+
+void WMDequeueNotificationMatching(WMNotificationQueue * queue, WMNotification * notification, unsigned mask)
+{
+	WMMatchDataProc *matchFunc;
+
+	if ((mask & WNCOnName) && (mask & WNCOnSender))
+		matchFunc = matchSenderAndName;
+	else if (mask & WNCOnName)
+		matchFunc = matchName;
+	else if (mask & WNCOnSender)
+		matchFunc = matchSender;
+	else
+		return;
+
+	WMRemoveFromArrayMatching(queue->asapQueue, matchFunc, notification);
+	WMRemoveFromArrayMatching(queue->idleQueue, matchFunc, notification);
+}
+
+void
+WMEnqueueCoalesceNotification(WMNotificationQueue * queue,
+			      WMNotification * notification, WMPostingStyle postingStyle, unsigned coalesceMask)
+{
+	if (coalesceMask != WNCNone)
+		WMDequeueNotificationMatching(queue, notification, coalesceMask);
+
+	switch (postingStyle) {
+	case WMPostNow:
+		WMPostNotification(notification);
+		WMReleaseNotification(notification);
+		break;
+
+	case WMPostASAP:
+		WMAddToArray(queue->asapQueue, notification);
+		break;
+
+	case WMPostWhenIdle:
+		WMAddToArray(queue->idleQueue, notification);
+		break;
+	}
+}
+
+void W_FlushASAPNotificationQueue(void)
+{
+	WMNotificationQueue *queue = notificationQueueList;
+
+	while (queue) {
+		while (WMGetArrayItemCount(queue->asapQueue)) {
+			WMPostNotification(WMGetFromArray(queue->asapQueue, 0));
+			WMDeleteFromArray(queue->asapQueue, 0);
+		}
+
+		queue = queue->next;
+	}
+}
+
+void W_FlushIdleNotificationQueue(void)
+{
+	WMNotificationQueue *queue = notificationQueueList;
+
+	while (queue) {
+		while (WMGetArrayItemCount(queue->idleQueue)) {
+			WMPostNotification(WMGetFromArray(queue->idleQueue, 0));
+			WMDeleteFromArray(queue->idleQueue, 0);
+		}
+
+		queue = queue->next;
+	}
+}

bazel/WINGs/po/Makefile.am

@@ -0,0 +1,125 @@
+DOMAIN = WINGs
+
+CATALOGS = @WINGSMOFILES@
+
+CLEANFILES = $(CATALOGS) $(DOMAIN).pot
+
+EXTRA_DIST = bg.po ca.po cs.po de.po fr.po fy.po hu.po nl.po sk.po sr.po
+
+# WUtil files:
+POTFILES  = \
+	$(top_srcdir)/WINGs/array.c \
+	$(top_srcdir)/WINGs/bagtree.c \
+	$(top_srcdir)/WINGs/data.c \
+	$(top_srcdir)/WINGs/error.c \
+	$(top_srcdir)/WINGs/findfile.c \
+	$(top_srcdir)/WINGs/handlers.c \
+	$(top_srcdir)/WINGs/hashtable.c \
+	$(top_srcdir)/WINGs/memory.c \
+	$(top_srcdir)/WINGs/menuparser.c \
+	$(top_srcdir)/WINGs/menuparser_macros.c \
+	$(top_srcdir)/WINGs/misc.c \
+	$(top_srcdir)/WINGs/notification.c \
+	$(top_srcdir)/WINGs/proplist.c \
+	$(top_srcdir)/WINGs/string.c \
+	$(top_srcdir)/WINGs/tree.c \
+	$(top_srcdir)/WINGs/userdefaults.c \
+	$(top_srcdir)/WINGs/usleep.c \
+	$(top_srcdir)/WINGs/wapplication.c \
+	$(top_srcdir)/WINGs/wutil.c
+
+# WINGs files:
+POTFILES += \
+	$(top_srcdir)/WINGs/configuration.c \
+	$(top_srcdir)/WINGs/dragcommon.c \
+	$(top_srcdir)/WINGs/dragdestination.c \
+	$(top_srcdir)/WINGs/dragsource.c \
+	$(top_srcdir)/WINGs/selection.c \
+	$(top_srcdir)/WINGs/wappresource.c \
+	$(top_srcdir)/WINGs/wballoon.c \
+	$(top_srcdir)/WINGs/wbox.c \
+	$(top_srcdir)/WINGs/wbrowser.c \
+	$(top_srcdir)/WINGs/wbutton.c \
+	$(top_srcdir)/WINGs/wcolor.c \
+	$(top_srcdir)/WINGs/wcolorpanel.c \
+	$(top_srcdir)/WINGs/wcolorwell.c \
+	$(top_srcdir)/WINGs/wevent.c \
+	$(top_srcdir)/WINGs/wfilepanel.c \
+	$(top_srcdir)/WINGs/wframe.c \
+	$(top_srcdir)/WINGs/wfont.c \
+	$(top_srcdir)/WINGs/wfontpanel.c \
+	$(top_srcdir)/WINGs/widgets.c \
+	$(top_srcdir)/WINGs/winputmethod.c \
+	$(top_srcdir)/WINGs/wlabel.c \
+	$(top_srcdir)/WINGs/wlist.c \
+	$(top_srcdir)/WINGs/wmenuitem.c \
+	$(top_srcdir)/WINGs/wmisc.c \
+	$(top_srcdir)/WINGs/wpanel.c \
+	$(top_srcdir)/WINGs/wpixmap.c \
+	$(top_srcdir)/WINGs/wpopupbutton.c \
+	$(top_srcdir)/WINGs/wprogressindicator.c \
+	$(top_srcdir)/WINGs/wruler.c \
+	$(top_srcdir)/WINGs/wscroller.c \
+	$(top_srcdir)/WINGs/wscrollview.c \
+	$(top_srcdir)/WINGs/wslider.c \
+	$(top_srcdir)/WINGs/wsplitview.c \
+	$(top_srcdir)/WINGs/wtabview.c \
+	$(top_srcdir)/WINGs/wtext.c \
+	$(top_srcdir)/WINGs/wtextfield.c \
+	$(top_srcdir)/WINGs/wview.c \
+	$(top_srcdir)/WINGs/wwindow.c
+
+SUFFIXES = .po .mo
+
+.po.mo:
+	$(AM_V_GEN)$(MSGFMT) -c -o $@ $<
+
+
+all-local: $(CATALOGS)
+
+
+.PHONY: update-lang
+
+if HAVE_XGETTEXT
+update-lang: $(DOMAIN).pot
+	$(AM_V_GEN)$(top_srcdir)/script/generate-po-from-template.sh \
+	    -n "$(PACKAGE_NAME)" -v "$(PACKAGE_VERSION)" -b "$(PACKAGE_BUGREPORT)" \
+	    -t "$(DOMAIN).pot"  "$(srcdir)/$(PO).po"
+
+$(DOMAIN).pot: $(POTFILES)
+	$(AM_V_GEN)$(XGETTEXT) --default-domain=$(DOMAIN) \
+	    --add-comments --keyword=_ --keyword=N_ $(POTFILES)
+	@if cmp -s $(DOMAIN).po $(DOMAIN).pot; then \
+	    rm -f $(DOMAIN).po; \
+	else \
+	    mv -f $(DOMAIN).po $(DOMAIN).pot; \
+	fi
+endif
+
+
+install-data-local:  $(CATALOGS)
+	$(mkinstalldirs) $(DESTDIR)$(localedir)
+	for n in $(CATALOGS) __DuMmY ; do \
+		if test "$$n" -a "$$n" != "__DuMmY" ; then \
+			l=`basename $$n .mo`; \
+			$(mkinstalldirs) $(DESTDIR)$(localedir)/$$l/LC_MESSAGES; \
+			$(INSTALL_DATA) -m 644 $$n $(DESTDIR)$(localedir)/$$l/LC_MESSAGES/$(DOMAIN).mo; \
+		fi; \
+	done
+
+uninstall-local:
+	for n in $(CATALOGS) ; do \
+		l=`basename $$n .mo`; \
+		rm -f $(DESTDIR)$(localedir)/$$l/LC_MESSAGES/$(DOMAIN).mo; \
+	done
+
+# Create a 'silent rule' for our make check the same way automake does
+AM_V_CHKTRANS = $(am__v_CHKTRANS_$(V))
+am__v_CHKTRANS_ = $(am__v_CHKTRANS_$(AM_DEFAULT_VERBOSITY))
+am__v_CHKTRANS_0 = @echo "  CHK     translations" ;
+am__v_CHKTRANS_1 =
+
+# 'make check' will make sure the tranlation sources are in line with the compiled source
+check-local:
+	$(AM_V_CHKTRANS)$(top_srcdir)/script/check-translation-sources.sh \
+		"$(srcdir)" -s "$(top_srcdir)/WINGs/Makefile.am"

bazel/WINGs/po/README

@@ -0,0 +1,16 @@
+File	Language	Note	Current Maintainer
+------------------------------------------------------------------------------
+ca.po	Catalan			Ernest Adrogué <eadrogue@gmx.net>
+cs.po	Czech		 	Jiri Hnidek <Jiri.Hnidek@vslib.cz
+de.po	German		 	Guido Scholz <guido.scholz@bayernline.de>
+fr.po	French			Emmanuel Benoit <tseeker@neptune.fr>
+				Antoine Hulin <antoine@origan.fdn.org>
+sk.po	Slovak		 	Jan 'judas' Tomka <judas@linux.sk>
+bg.po	Bulgarian		Anton Zinoviev <zinoviev@debian.org>
+nl.po	Dutch			Alwin <translations@ziggo.nl>
+fy.po	Frisian			Alwin <translations@ziggo.nl>
+sr.po	Serbian			Strahinya Radich <contact@strahinja.org>
+
+Notes
+-----
+

bazel/WINGs/po/bg.po

@@ -0,0 +1,660 @@
+# Message catalog for WINGs
+# Copyright (C) 2003 Free Software Foundation, Inc.
+# Anton Zinoviev <zinoviev@debian.org>, 2003
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: WINGs 0.80.0\n"
+"POT-Creation-Date: 2003-02-08 21:42+0200\n"
+"PO-Revision-Date: 2003-02-09 12:10+0200\n"
+"Last-Translator: Anton Zinoviev <zinoviev@debian.org>\n"
+"Language-Team: Bulgarian <dict@linux.zonebg.com>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../../WINGs/connection.c:461 ../../WINGs/connection.c:526
+#: ../../WINGs/connection.c:569
+msgid "Bad address-service-protocol combination"
+msgstr "Неправилна комбинация адрес-услуга-протокол"
+
+#: ../../WINGs/error.c:54
+#, c-format
+msgid "Unknown error %d"
+msgstr "Непозната грешка %d"
+
+#: ../../WINGs/error.c:59
+#, c-format
+msgid "Error %d"
+msgstr "Грешка %d"
+
+#: ../../WINGs/error.c:110
+msgid "warning: "
+msgstr "внимание: "
+
+#: ../../WINGs/error.c:137
+msgid "fatal: "
+msgstr "критична грешка: "
+
+#: ../../WINGs/error.c:163 ../../WINGs/error.c:192
+msgid "error: "
+msgstr "грешка: "
+
+#: ../../WINGs/findfile.c:48
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "не може да се получи записът за парола на потребител с номер %i"
+
+#: ../../WINGs/findfile.c:66
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "не може да се получи записът за парола на потребител %s<"
+
+#: ../../WINGs/host.c:114
+msgid "Cannot get current host name"
+msgstr "Не може да се получи името на хоста"
+
+#: ../../WINGs/proplist.c:91
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "синтактична грешка в %s %s, ред %i: %s"
+
+#: ../../WINGs/proplist.c:150
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr "Като ключ за достъп до proplist се поддържат само низове или данни"
+
+#: ../../WINGs/proplist.c:184 ../../WINGs/proplist.c:236
+#: ../../WINGs/proplist.c:394 ../../WINGs/proplist.c:474
+#: ../../WINGs/proplist.c:1075 ../../WINGs/proplist.c:1127
+#: ../../WINGs/proplist.c:1293 ../../WINGs/proplist.c:1372
+#: ../../WINGs/proplist.c:1493 ../../WINGs/proplist.c:1540
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr "Ползват се proplist-функции за обекти, които не са от тип WMPropLists"
+
+#: ../../WINGs/proplist.c:630
+msgid "unterminated PropList string"
+msgstr "незавършен низ PropList"
+
+#: ../../WINGs/proplist.c:670
+msgid "unterminated PropList data"
+msgstr "незавършени данни PropList"
+
+#: ../../WINGs/proplist.c:678
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr "незавършени данни PropList (липсва шестнадесетично число)"
+
+#: ../../WINGs/proplist.c:690 ../../WINGs/proplist.c:695
+msgid "non hexdigit character in PropList data"
+msgstr "знак, който не е шестнадесетично число, в данни PropList"
+
+#: ../../WINGs/proplist.c:729
+msgid "unterminated PropList array"
+msgstr "незавършен масив PropList"
+
+#: ../../WINGs/proplist.c:737
+msgid "missing or unterminated PropList array"
+msgstr "липсващ или незавършен масив Proplist"
+
+#: ../../WINGs/proplist.c:747
+msgid "could not get PropList array element"
+msgstr "не може да се получи елемент от масив PropList"
+
+#: ../../WINGs/proplist.c:776
+msgid "unterminated PropList dictionary"
+msgstr "незавършен речник PropList"
+
+#: ../../WINGs/proplist.c:793
+msgid "missing PropList dictionary key"
+msgstr "липсващ ключ за достъп до PropList"
+
+#: ../../WINGs/proplist.c:795
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr "липсващ ключ за достъп до PropList или незавършен речник"
+
+#: ../../WINGs/proplist.c:803
+msgid "error parsing PropList dictionary key"
+msgstr "грешка при разбор на ключ в PropList"
+
+#: ../../WINGs/proplist.c:811
+msgid "missing = in PropList dictionary entry"
+msgstr "липсва знак за равенство в елемент на PropList"
+
+#: ../../WINGs/proplist.c:819
+msgid "error parsing PropList dictionary entry value"
+msgstr "грешка при разбор на стойност на елемент в PropList"
+
+#: ../../WINGs/proplist.c:827
+msgid "missing ; in PropList dictionary entry"
+msgstr "липсва знак точка и запетая в елемент на PropList"
+
+#: ../../WINGs/proplist.c:888
+msgid ""
+"was expecting a string, data, array or dictionary. If it's a string, try "
+"enclosing it with \"."
+msgstr "очакваха се низ, данни, масив или речник. Ако е речник, пробвайте да го оградите с \"."
+
+#: ../../WINGs/proplist.c:892
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "Не се позволяват коментари във файлове с области, собственост на Уиндоу Мейкър"
+
+#: ../../WINGs/proplist.c:1563 ../../WINGs/proplist.c:1628
+msgid "extra data after end of property list"
+msgstr "данни в повече след края на списък свойства"
+
+#: ../../WINGs/proplist.c:1606
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "не може да се получи размерът за файл \"%s\""
+
+#: ../../WINGs/proplist.c:1618
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "грешка при четене от файл \"%s\""
+
+#: ../../WINGs/proplist.c:1669
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "mkstemp (%s) не успя"
+
+#: ../../WINGs/proplist.c:1680
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "mktemp (%s) не успя"
+
+#: ../../WINGs/proplist.c:1691
+#, c-format
+msgid "open (%s) failed"
+msgstr "open (%s) не успя"
+
+#: ../../WINGs/proplist.c:1698
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "записът във файл %s не успя"
+
+#: ../../WINGs/proplist.c:1706
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "fclose (%s) не успя"
+
+#: ../../WINGs/proplist.c:1715
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "преименуването (от \"%s\" на \"%s\") не успя"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:192 ../../WINGs/userdefaults.c:208
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "не може да се прочете областта от файл \"%s\" при синхронизиране"
+
+#: ../../WINGs/wcolor.c:198 ../../WINGs/wcolor.c:211 ../../WINGs/wcolor.c:250
+#: ../../WINGs/wcolor.c:291
+#, c-format
+msgid "could not allocate %s color"
+msgstr "не може да се задели цвят %s"
+
+#: ../../WINGs/wcolor.c:198
+msgid "white"
+msgstr "бял"
+
+#: ../../WINGs/wcolor.c:211
+msgid "black"
+msgstr "черен"
+
+#: ../../WINGs/wcolor.c:250
+msgid "gray"
+msgstr "сив"
+
+#: ../../WINGs/wcolor.c:291
+msgid "dark gray"
+msgstr "тъмносив"
+
+#: ../../WINGs/wcolorpanel.c:415
+msgid "Colors"
+msgstr "Цветове"
+
+#: ../../WINGs/wcolorpanel.c:605 ../../WINGs/wcolorpanel.c:2824
+msgid "Brightness"
+msgstr "Яркост"
+
+#: ../../WINGs/wcolorpanel.c:607 ../../WINGs/wcolorpanel.c:683
+#: ../../WINGs/wcolorpanel.c:716 ../../WINGs/wcolorpanel.c:750
+#: ../../WINGs/wcolorpanel.c:810 ../../WINGs/wcolorpanel.c:844
+#: ../../WINGs/wcolorpanel.c:878 ../../WINGs/wcolorpanel.c:913
+#: ../../WINGs/wcolorpanel.c:2164 ../../WINGs/wcolorpanel.c:2826
+#: ../../WINGs/wcolorpanel.c:2862 ../../WINGs/wcolorpanel.c:2898
+#: ../../WINGs/wcolorpanel.c:3746
+msgid "Color Panel: Could not allocate memory"
+msgstr "Color Panel: не може да се задели памет"
+
+#: ../../WINGs/wcolorpanel.c:680 ../../WINGs/wcolorpanel.c:681
+msgid "Red"
+msgstr "Червен"
+
+#: ../../WINGs/wcolorpanel.c:713 ../../WINGs/wcolorpanel.c:714
+msgid "Green"
+msgstr "Зелен"
+
+#: ../../WINGs/wcolorpanel.c:747 ../../WINGs/wcolorpanel.c:748
+msgid "Blue"
+msgstr "Син"
+
+#: ../../WINGs/wcolorpanel.c:807 ../../WINGs/wcolorpanel.c:808
+msgid "Cyan"
+msgstr "Синьозелен"
+
+#: ../../WINGs/wcolorpanel.c:841 ../../WINGs/wcolorpanel.c:842
+msgid "Magenta"
+msgstr "Пурпурен"
+
+#: ../../WINGs/wcolorpanel.c:875 ../../WINGs/wcolorpanel.c:876
+msgid "Yellow"
+msgstr "Жълт"
+
+#: ../../WINGs/wcolorpanel.c:910 ../../WINGs/wcolorpanel.c:911
+msgid "Black"
+msgstr "Черен"
+
+#: ../../WINGs/wcolorpanel.c:991
+msgid "Spectrum"
+msgstr "Спектър"
+
+#: ../../WINGs/wcolorpanel.c:1021
+msgid "Palette"
+msgstr "Палитра"
+
+#: ../../WINGs/wcolorpanel.c:1027
+msgid "New from File..."
+msgstr "Нова от файл..."
+
+#: ../../WINGs/wcolorpanel.c:1028 ../../WINGs/wcolorpanel.c:1076
+#: ../../WINGs/wcolorpanel.c:1093
+msgid "Rename..."
+msgstr "Преименувай..."
+
+#: ../../WINGs/wcolorpanel.c:1029 ../../WINGs/wcolorpanel.c:1077
+#: ../../WINGs/wcolorpanel.c:1094 ../../WINGs/wcolorpanel.c:3321
+msgid "Remove"
+msgstr "Премахни"
+
+#: ../../WINGs/wcolorpanel.c:1030
+msgid "Copy"
+msgstr "Копирай"
+
+#: ../../WINGs/wcolorpanel.c:1031
+#, fuzzy
+msgid "New from Clipboard"
+msgstr "Нова от Clipboard"
+
+#: ../../WINGs/wcolorpanel.c:1052
+msgid "X11-Colors"
+msgstr "Цветове от X11"
+
+#: ../../WINGs/wcolorpanel.c:1069
+msgid "Color"
+msgstr "Цвят"
+
+#: ../../WINGs/wcolorpanel.c:1075
+msgid "Add..."
+msgstr "Добави..."
+
+#: ../../WINGs/wcolorpanel.c:1085
+msgid "List"
+msgstr "Списък"
+
+#: ../../WINGs/wcolorpanel.c:1092
+msgid "New..."
+msgstr "Нов..."
+
+#: ../../WINGs/wcolorpanel.c:1231
+#, c-format
+msgid ""
+"Color Panel: Could not create directory %s needed to store configurations"
+msgstr "Color Panel: Не може да се създаде директория %s, необходима за да се запазят настройките"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1237 ../../WINGs/wcolorpanel.c:3207
+#: ../../WINGs/wcolorpanel.c:3211
+msgid "File Error"
+msgstr "Файлова грешка"
+
+#: ../../WINGs/wcolorpanel.c:1238
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Не може да се създаде конфигурационна директория за ColorPanel"
+
+#: ../../WINGs/wcolorpanel.c:1239 ../../WINGs/wcolorpanel.c:3208
+#: ../../WINGs/wcolorpanel.c:3213 ../../WINGs/wcolorpanel.c:3240
+#: ../../WINGs/wfilepanel.c:250 ../../WINGs/wfilepanel.c:647
+#: ../../WINGs/wfilepanel.c:659 ../../WINGs/wfilepanel.c:760
+#: ../../WINGs/wfilepanel.c:971 ../../WINGs/wfontpanel.c:709
+msgid "OK"
+msgstr "Приемам"
+
+#: ../../WINGs/wcolorpanel.c:1245 ../../WINGs/wcolorpanel.c:1281
+#: ../../WINGs/wcolorpanel.c:1299
+msgid "Color Panel: Could not find file"
+msgstr "Color Panel: Не може да се открие файла"
+
+#: ../../WINGs/wcolorpanel.c:1486 ../../WINGs/wcolorpanel.c:1551
+#: ../../WINGs/wcolorpanel.c:1615
+msgid "Color Panel: X failed request"
+msgstr "Color Panel: не успя заявка към X"
+
+#: ../../WINGs/wcolorpanel.c:2860
+msgid "Saturation"
+msgstr "Наситеност"
+
+#: ../../WINGs/wcolorpanel.c:2896
+msgid "Hue"
+msgstr "Нюанс"
+
+#: ../../WINGs/wcolorpanel.c:3146
+msgid "Open Palette"
+msgstr "Отваряне на палитра"
+
+#: ../../WINGs/wcolorpanel.c:3208
+msgid "Invalid file format !"
+msgstr "Неправилен файлов формат!"
+
+#: ../../WINGs/wcolorpanel.c:3210
+#, c-format
+msgid "can't remove file %s"
+msgstr "не може да се изтрие файлът %s"
+
+#: ../../WINGs/wcolorpanel.c:3212
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Не може да се изтрие файл от директорията за настройки!"
+
+#: ../../WINGs/wcolorpanel.c:3239
+msgid "Rename"
+msgstr "Преименуване"
+
+#: ../../WINGs/wcolorpanel.c:3239
+msgid "Rename palette to:"
+msgstr "Преименувай палитрата на "
+
+#: ../../WINGs/wcolorpanel.c:3240 ../../WINGs/wfilepanel.c:259
+#: ../../WINGs/wfilepanel.c:659 ../../WINGs/wfilepanel.c:760
+msgid "Cancel"
+msgstr "Отменям"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3256 ../../WINGs/wfilepanel.c:760
+msgid "Warning"
+msgstr "Внимание"
+
+#: ../../WINGs/wcolorpanel.c:3257
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Такава палитра вече съществува!\n"
+"\n"
+"Да бъде ли заменена с новата?"
+
+#: ../../WINGs/wcolorpanel.c:3257 ../../WINGs/wcolorpanel.c:3321
+msgid "No"
+msgstr "Не"
+
+#: ../../WINGs/wcolorpanel.c:3257 ../../WINGs/wcolorpanel.c:3321
+msgid "Yes"
+msgstr "Да"
+
+#: ../../WINGs/wcolorpanel.c:3289
+#, c-format
+msgid "Couldn't rename palette %s to %s\n"
+msgstr "Палитрата %s не може да се преименува на %s\n"
+
+#: ../../WINGs/wcolorpanel.c:3315
+msgid "This will permanently remove the palette "
+msgstr "Това ще отстрани палитрата необратимо "
+
+#: ../../WINGs/wcolorpanel.c:3318
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+".\n"
+"\n"
+"Убедени ли сте, че искате да отстраните тази палитра?"
+
+#: ../../WINGs/wcolorpanel.c:3343
+#, c-format
+msgid "Couldn't remove palette %s\n"
+msgstr "Палитрата %s не може да бъде отстранена\n"
+
+#: ../../WINGs/wcolorpanel.c:3648
+#, c-format
+msgid "Could not open %s"
+msgstr "Не може да бъде отворен %s"
+
+#: ../../WINGs/wcolorpanel.c:3655
+#, c-format
+msgid "Could not create %s"
+msgstr "Не може да бъде създаден %s"
+
+#: ../../WINGs/wcolorpanel.c:3666
+#, c-format
+msgid "Write error on file %s"
+msgstr "Грешка при запис във файл %s"
+
+#: ../../WINGs/wcolorpanel.c:3711
+msgid "Color Panel: Color unspecified"
+msgstr "Color Panel: Не е посочен цвят"
+
+#: ../../WINGs/wfilepanel.c:235
+msgid "Name:"
+msgstr "Име:"
+
+#: ../../WINGs/wfilepanel.c:332 ../../WINGs/wfilepanel.c:396
+msgid "Open"
+msgstr "Отвори"
+
+#: ../../WINGs/wfilepanel.c:350 ../../WINGs/wfilepanel.c:402
+msgid "Save"
+msgstr "Запази"
+
+#: ../../WINGs/wfilepanel.c:562
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: директорията %s не може да се отвори\n"
+
+#: ../../WINGs/wfilepanel.c:580
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: не могат да се получат атрибутите (stat) за %s\n"
+
+#: ../../WINGs/wfilepanel.c:647 ../../WINGs/wfilepanel.c:970
+#: ../../WINGs/wfontpanel.c:708
+msgid "Error"
+msgstr "Грешка"
+
+#: ../../WINGs/wfilepanel.c:658
+msgid "Create Directory"
+msgstr "Създаване на директория"
+
+#: ../../WINGs/wfilepanel.c:659
+msgid "Enter directory name"
+msgstr "Въведете името на директорията"
+
+#: ../../WINGs/wfilepanel.c:695 ../../WINGs/wfilepanel.c:734
+#: ../../WINGs/wfilepanel.c:765 ../../WINGs/wfilepanel.c:793
+msgid "Permission denied."
+msgstr "Отказан достъп"
+
+#: ../../WINGs/wfilepanel.c:698
+#, c-format
+msgid "'%s' already exists."
+msgstr "вече съществува \"%s\"."
+
+#: ../../WINGs/wfilepanel.c:701
+msgid "Path does not exist."
+msgstr "Пътят не съществува."
+
+#: ../../WINGs/wfilepanel.c:731 ../../WINGs/wfilepanel.c:790
+#, c-format
+msgid "'%s' does not exist."
+msgstr "Не съществува \"%s\"."
+
+#: ../../WINGs/wfilepanel.c:738 ../../WINGs/wfilepanel.c:797
+msgid "Insufficient memory available."
+msgstr "Не е достъпна достатъчно памет."
+
+#: ../../WINGs/wfilepanel.c:742 ../../WINGs/wfilepanel.c:801
+#, c-format
+msgid "'%s' is on a read-only filesystem."
+msgstr "\"%s\" се намира във файлова система с достъп само за четене."
+
+#: ../../WINGs/wfilepanel.c:745 ../../WINGs/wfilepanel.c:777
+#: ../../WINGs/wfilepanel.c:804
+#, c-format
+msgid "Can not delete '%s'."
+msgstr "\"%s\" не може да бъде изтрит."
+
+#: ../../WINGs/wfilepanel.c:752
+#, c-format
+msgid "Delete directory %s ?"
+msgstr "Да се изтрие ли директорията %s?"
+
+#: ../../WINGs/wfilepanel.c:756
+#, c-format
+msgid "Delete file %s ?"
+msgstr "Да се изтрие ли файлът %s?"
+
+#: ../../WINGs/wfilepanel.c:768
+#, c-format
+msgid "Directory '%s' does not exist."
+msgstr "Директорията \"%s\" не съществува."
+
+#: ../../WINGs/wfilepanel.c:771
+#, c-format
+msgid "Directory '%s' is not empty."
+msgstr "Директорията \"%s\" не е празна."
+
+#: ../../WINGs/wfilepanel.c:774
+#, c-format
+msgid "Directory '%s' is busy."
+msgstr "Директорията \"%s е заета."
+
+#: ../../WINGs/wfilepanel.c:787
+#, c-format
+msgid "'%s' is a directory."
+msgstr "\"%s\" е директория."
+
+#: ../../WINGs/wfilepanel.c:829
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Настъпи грешка при показване на \"%s\"."
+
+#: ../../WINGs/wfilepanel.c:833
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "\"%s\" не е директория."
+
+#: ../../WINGs/wfilepanel.c:970
+msgid "File does not exist."
+msgstr "Файлът не съществува."
+
+#: ../../WINGs/wfont.c:129
+#, c-format
+msgid "the following character sets are missing in %s:"
+msgstr "в %s липсват следните кодирания:"
+
+#: ../../WINGs/wfont.c:136
+#, c-format
+msgid ""
+"the string \"%s\" will be used in place of any characters from those sets."
+msgstr "Вместо кой да е символ от тези кодирания ще се използва низът \"%s\"."
+
+#: ../../WINGs/wfont.c:300 ../../WINGs/wfont.c:336
+#, c-format
+msgid "could not load font set %s. Trying fixed."
+msgstr "не може да се зареди шрифтова комбинация %s. Опит за шрифт fixed."
+
+#: ../../WINGs/wfont.c:306 ../../WINGs/wfont.c:342
+#, c-format
+msgid "could not load font %s. Trying fixed."
+msgstr "не може да се зареди шрифт %s. Опит за шрифт fixed."
+
+#: ../../WINGs/wfont.c:310 ../../WINGs/wfont.c:346
+msgid "could not load fixed font!"
+msgstr "не може да се зареди шрифтът fixed!"
+
+#: ../../WINGs/wfont.c:441
+#, c-format
+msgid "font description %s is too large."
+msgstr "шрифтовото описание %s е твърде дълго."
+
+#: ../../WINGs/wfontpanel.c:205
+msgid "Test!!!"
+msgstr "Проба!!! Test!!!"
+
+#: ../../WINGs/wfontpanel.c:211
+msgid "Family"
+msgstr "Гарнитура"
+
+#: ../../WINGs/wfontpanel.c:222
+msgid "Typeface"
+msgstr "Стил"
+
+#: ../../WINGs/wfontpanel.c:233
+msgid "Size"
+msgstr "Размер"
+
+#: ../../WINGs/wfontpanel.c:252
+msgid "Set"
+msgstr "Установи"
+
+#: ../../WINGs/wfontpanel.c:257
+msgid "Revert"
+msgstr "Предишното"
+
+#: ../../WINGs/wfontpanel.c:709
+msgid "Could not retrieve font list"
+msgstr "Не може да се получи списъка от шрифтове"
+
+#: ../../WINGs/wfontpanel.c:721
+#, c-format
+msgid "font name %s is longer than 256, which is invalid."
+msgstr "името на шрифта %s е по-дълго от 256 символа, което е недопустимо."
+
+#: ../../WINGs/wfontpanel.c:868
+msgid "Roman"
+msgstr "Изправен"
+
+#: ../../WINGs/wfontpanel.c:871
+msgid "Italic"
+msgstr "Курсив"
+
+#: ../../WINGs/wfontpanel.c:873
+msgid "Oblique"
+msgstr "Наклонен"
+
+#: ../../WINGs/wfontpanel.c:875
+msgid "Rev Italic"
+msgstr "Обратен курсив"
+
+#: ../../WINGs/wfontpanel.c:877
+msgid "Rev Oblique"
+msgstr "Обратно наклонен"
+
+#: ../../WINGs/wfontpanel.c:883
+msgid "Normal"
+msgstr "Нормален"
+
+#: ../../WINGs/widgets.c:415
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: не може да се зареди изображението %s на библиотеката."
+
+#: ../../WINGs/widgets.c:763
+msgid ""
+"could not load any fonts. Make sure your font installation and locale "
+"settings are correct."
+msgstr "не може да се зареди никакъв шрифт. Убедете се, че имате правилно инсталирани шрифтове и посочен езиков локал."
+
+#: ../../WINGs/wruler.c:189
+msgid "0   inches"
+msgstr "0   цола"

bazel/WINGs/po/ca.po

@@ -0,0 +1,736 @@
+# Catalan messages for WINGs.
+# Copyright (C) 2003 Ernest Adrogué <eadrogue@gmx.net>.
+# This file is distributed under the terms of the GNU General Public License.
+#
+# Version history:
+# 	WM-ver		author		email			date
+# 	0.80.2		Ernest Adrogué	eadrogue@gmx.net	23 Feb 2003
+# 	CVS-20030914	Ernest Adrogué	eadrogue@gmx.net	15 Set 2003
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: WINGs 0.80.2\n"
+"POT-Creation-Date: 2003-09-16 22:59+0200\n"
+"PO-Revision-Date: 2003-09-16 23:16+0200\n"
+"Last-Translator: Ernest Adrogué <eadrogue@gmx.net>\n"
+"Language-Team: Catalan <ca@dodds.net>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../../WINGs/connection.c:467 ../../WINGs/connection.c:532
+#: ../../WINGs/connection.c:575
+msgid "Bad address-service-protocol combination"
+msgstr "Combinació adreça-servei-protocol incorrecta"
+
+#: ../../WINGs/error.c:54
+#, c-format
+msgid "Unknown error %d"
+msgstr "Error no identificat %d"
+
+#: ../../WINGs/error.c:59
+#, c-format
+msgid "Error %d"
+msgstr "Error %d"
+
+#: ../../WINGs/error.c:110
+msgid "warning: "
+msgstr "atenció: "
+
+#: ../../WINGs/error.c:137
+msgid "fatal: "
+msgstr "error fatal: "
+
+#: ../../WINGs/error.c:163 ../../WINGs/error.c:192
+msgid "error: "
+msgstr "error: "
+
+#: ../../WINGs/findfile.c:48
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "no s'ha pogut obtenir l'informació de compte de l'UID %i"
+
+#: ../../WINGs/findfile.c:66
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "no s'ha pogut obtenir l'informació de compte de l'usuari %s"
+
+#: ../../WINGs/host.c:114
+msgid "Cannot get current host name"
+msgstr "No s'ha pogut obtenir el nom de host actual"
+
+# falten coses per traduïr en el codi font. eac
+#: ../../WINGs/proplist.c:91
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "error de sintaxi a %s %s, línia %i: %s"
+
+#: ../../WINGs/proplist.c:150
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr ""
+"Una entrada PropList de diccionari només pot contenir dades o una cadena"
+
+#: ../../WINGs/proplist.c:184 ../../WINGs/proplist.c:236
+#: ../../WINGs/proplist.c:394 ../../WINGs/proplist.c:474
+#: ../../WINGs/proplist.c:1075 ../../WINGs/proplist.c:1127
+#: ../../WINGs/proplist.c:1293 ../../WINGs/proplist.c:1372
+#: ../../WINGs/proplist.c:1493 ../../WINGs/proplist.c:1540
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr "S'han usat funcions PropList en objectes no-WMPropLists"
+
+#: ../../WINGs/proplist.c:630
+msgid "unterminated PropList string"
+msgstr "cadena PropList incompleta"
+
+#: ../../WINGs/proplist.c:670
+msgid "unterminated PropList data"
+msgstr "dades PropList incompletes"
+
+#: ../../WINGs/proplist.c:678
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr "Dades PropList incompletes (falta un digit hexadecimal)"
+
+#: ../../WINGs/proplist.c:690 ../../WINGs/proplist.c:695
+msgid "non hexdigit character in PropList data"
+msgstr "cap digit hexadecimal a les dades PropList"
+
+#: ../../WINGs/proplist.c:729
+msgid "unterminated PropList array"
+msgstr "matriu PropList incompleta"
+
+#: ../../WINGs/proplist.c:737
+msgid "missing or unterminated PropList array"
+msgstr "matriu PropList incompleta o inexistent"
+
+#: ../../WINGs/proplist.c:747
+msgid "could not get PropList array element"
+msgstr "no s'ha pogut obtenir un element de la matriu PropList"
+
+#: ../../WINGs/proplist.c:776
+msgid "unterminated PropList dictionary"
+msgstr "diccionari PropList incomplet"
+
+#: ../../WINGs/proplist.c:793
+msgid "missing PropList dictionary key"
+msgstr "falta una entrada PropList de diccionari"
+
+#: ../../WINGs/proplist.c:795
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr "falta una entrada PropList de diccionari o bé està incompleta"
+
+#: ../../WINGs/proplist.c:803
+msgid "error parsing PropList dictionary key"
+msgstr "error mentre s'analitzava l'entrada PropList de diccionari"
+
+#: ../../WINGs/proplist.c:811
+msgid "missing = in PropList dictionary entry"
+msgstr "falta un \"=\" a l'entrada PropList de diccionari"
+
+#: ../../WINGs/proplist.c:819
+msgid "error parsing PropList dictionary entry value"
+msgstr "error mentre s'analitzava el valor de l'entrada PropList de diccionari"
+
+#: ../../WINGs/proplist.c:827
+msgid "missing ; in PropList dictionary entry"
+msgstr "falta un \";\" a l'entrada PropList de diccionari"
+
+#: ../../WINGs/proplist.c:888
+msgid ""
+"was expecting a string, data, array or dictionary. If it's a string, try "
+"enclosing it with \"."
+msgstr ""
+"s'esperava una cadena, dada, matriu o diccionari. Si es tractava d'una\n"
+"cadena proveu d'escriure-la \"entre cometes\"."
+
+#: ../../WINGs/proplist.c:892
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "No es permeten comentaris en els fitxers de domini de WindowMaker."
+
+#: ../../WINGs/proplist.c:1563 ../../WINGs/proplist.c:1630
+msgid "extra data after end of property list"
+msgstr "sobren dades després de la llista de propietats"
+
+#: ../../WINGs/proplist.c:1606
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "no s'ha pogut obtenir la mida de \"%s\""
+
+#: ../../WINGs/proplist.c:1619
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "error mentre es llegia el fitxer \"%s\""
+
+#: ../../WINGs/proplist.c:1671
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "la rutina mkstemp (%s) ha fallat"
+
+#: ../../WINGs/proplist.c:1682
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "la rutina mktemp (%s) ha fallat"
+
+#: ../../WINGs/proplist.c:1693
+#, c-format
+msgid "open (%s) failed"
+msgstr "la rutina open (%s) ha fallat"
+
+#: ../../WINGs/proplist.c:1700
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "l'escriptura del fitxer \"%s\" ha fallat"
+
+#: ../../WINGs/proplist.c:1708
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "la rutina fclose (%s) ha fallat"
+
+#: ../../WINGs/proplist.c:1717
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "el canvi de nom (\"%s\" a \"%s\") ha fallat"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:188 ../../WINGs/userdefaults.c:204
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "no s'ha pogut llegir un domini del fitxer \"%s\" quan es sincronitzava"
+
+#: ../../WINGs/wcolor.c:224 ../../WINGs/wcolor.c:236 ../../WINGs/wcolor.c:275
+#: ../../WINGs/wcolor.c:316
+#, c-format
+msgid "could not allocate %s color"
+msgstr "no s'ha pogut assignar espai pel color \"%s\""
+
+#: ../../WINGs/wcolor.c:224
+msgid "white"
+msgstr "blanc"
+
+#: ../../WINGs/wcolor.c:236
+msgid "black"
+msgstr "negre"
+
+#: ../../WINGs/wcolor.c:275
+msgid "gray"
+msgstr "gris"
+
+#: ../../WINGs/wcolor.c:316
+msgid "dark gray"
+msgstr "gris fosc"
+
+#: ../../WINGs/wcolorpanel.c:420
+msgid "Colors"
+msgstr "Colors"
+
+#: ../../WINGs/wcolorpanel.c:610 ../../WINGs/wcolorpanel.c:2829
+msgid "Brightness"
+msgstr "Claror"
+
+#: ../../WINGs/wcolorpanel.c:612 ../../WINGs/wcolorpanel.c:688
+#: ../../WINGs/wcolorpanel.c:721 ../../WINGs/wcolorpanel.c:755
+#: ../../WINGs/wcolorpanel.c:815 ../../WINGs/wcolorpanel.c:849
+#: ../../WINGs/wcolorpanel.c:883 ../../WINGs/wcolorpanel.c:918
+#: ../../WINGs/wcolorpanel.c:2169 ../../WINGs/wcolorpanel.c:2831
+#: ../../WINGs/wcolorpanel.c:2867 ../../WINGs/wcolorpanel.c:2903
+#: ../../WINGs/wcolorpanel.c:3745
+msgid "Color Panel: Could not allocate memory"
+msgstr "Panell de color: No s'ha pogut assignar memòria"
+
+#: ../../WINGs/wcolorpanel.c:685 ../../WINGs/wcolorpanel.c:686
+msgid "Red"
+msgstr "Roig"
+
+#: ../../WINGs/wcolorpanel.c:718 ../../WINGs/wcolorpanel.c:719
+msgid "Green"
+msgstr "Verd"
+
+#: ../../WINGs/wcolorpanel.c:752 ../../WINGs/wcolorpanel.c:753
+msgid "Blue"
+msgstr "Blau"
+
+#: ../../WINGs/wcolorpanel.c:812 ../../WINGs/wcolorpanel.c:813
+msgid "Cyan"
+msgstr "Cian"
+
+#: ../../WINGs/wcolorpanel.c:846 ../../WINGs/wcolorpanel.c:847
+msgid "Magenta"
+msgstr "Magenta"
+
+#: ../../WINGs/wcolorpanel.c:880 ../../WINGs/wcolorpanel.c:881
+msgid "Yellow"
+msgstr "Groc"
+
+#: ../../WINGs/wcolorpanel.c:915 ../../WINGs/wcolorpanel.c:916
+msgid "Black"
+msgstr "Negre"
+
+#: ../../WINGs/wcolorpanel.c:996
+msgid "Spectrum"
+msgstr "Espectre"
+
+#: ../../WINGs/wcolorpanel.c:1026
+msgid "Palette"
+msgstr "Paleta"
+
+#: ../../WINGs/wcolorpanel.c:1032
+msgid "New from File..."
+msgstr "Obtenir d'un fitxer..."
+
+#: ../../WINGs/wcolorpanel.c:1033 ../../WINGs/wcolorpanel.c:1081
+#: ../../WINGs/wcolorpanel.c:1098
+msgid "Rename..."
+msgstr "Reanomenar..."
+
+#: ../../WINGs/wcolorpanel.c:1034 ../../WINGs/wcolorpanel.c:1082
+#: ../../WINGs/wcolorpanel.c:1099 ../../WINGs/wcolorpanel.c:3326
+msgid "Remove"
+msgstr "Eliminar"
+
+#: ../../WINGs/wcolorpanel.c:1035
+msgid "Copy"
+msgstr "Copiar"
+
+#: ../../WINGs/wcolorpanel.c:1036
+msgid "New from Clipboard"
+msgstr "Obtenir del porta-retalls..."
+
+#: ../../WINGs/wcolorpanel.c:1057
+msgid "X11-Colors"
+msgstr "Colors-X11"
+
+#: ../../WINGs/wcolorpanel.c:1074
+msgid "Color"
+msgstr "Color"
+
+#: ../../WINGs/wcolorpanel.c:1080
+msgid "Add..."
+msgstr "Afegeix..."
+
+#: ../../WINGs/wcolorpanel.c:1090
+msgid "List"
+msgstr "Llista"
+
+#: ../../WINGs/wcolorpanel.c:1097
+msgid "New..."
+msgstr "Nou..."
+
+#: ../../WINGs/wcolorpanel.c:1236
+#, c-format
+msgid ""
+"Color Panel: Could not create directory %s needed to store configurations"
+msgstr ""
+"Panell de color: No s'ha pogut crear el directori \"%s\" necessari per desar "
+"la configuració"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1242 ../../WINGs/wcolorpanel.c:3212
+#: ../../WINGs/wcolorpanel.c:3216
+msgid "File Error"
+msgstr "Error de fitxer"
+
+#: ../../WINGs/wcolorpanel.c:1243
+msgid "Could not create ColorPanel configuration directory"
+msgstr "No s'ha pogut crear el directori de configuració del Panell de color"
+
+#: ../../WINGs/wcolorpanel.c:1244 ../../WINGs/wcolorpanel.c:3213
+#: ../../WINGs/wcolorpanel.c:3218 ../../WINGs/wcolorpanel.c:3245
+#: ../../WINGs/wfilepanel.c:250 ../../WINGs/wfilepanel.c:650
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+#: ../../WINGs/wfilepanel.c:974 ../../WINGs/wfontpanel.c:751
+msgid "OK"
+msgstr "D'acord"
+
+#: ../../WINGs/wcolorpanel.c:1250 ../../WINGs/wcolorpanel.c:1286
+#: ../../WINGs/wcolorpanel.c:1304
+msgid "Color Panel: Could not find file"
+msgstr "Panell de color: No s'ha trobat el fitxer"
+
+#: ../../WINGs/wcolorpanel.c:1491 ../../WINGs/wcolorpanel.c:1556
+#: ../../WINGs/wcolorpanel.c:1620
+msgid "Color Panel: X failed request"
+msgstr "Panell de color: petició X fallida"
+
+#: ../../WINGs/wcolorpanel.c:2865
+msgid "Saturation"
+msgstr "Saturació"
+
+#: ../../WINGs/wcolorpanel.c:2901
+msgid "Hue"
+msgstr "Matís"
+
+# és el títol d'un quadre de diàleg. eac
+#: ../../WINGs/wcolorpanel.c:3151
+msgid "Open Palette"
+msgstr "Obrir paleta"
+
+#: ../../WINGs/wcolorpanel.c:3213
+msgid "Invalid file format !"
+msgstr "El format del fitxer no és vàlid !"
+
+#: ../../WINGs/wcolorpanel.c:3215
+#, c-format
+msgid "can't remove file %s"
+msgstr "no s'ha pogut eliminar el fitxer \"%s\""
+
+#: ../../WINGs/wcolorpanel.c:3217
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "No s'ha pogut eliminar el fitxer del directori de configuració !"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename"
+msgstr "Reanomena"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename palette to:"
+msgstr "Reanomena la paleta com a:"
+
+#: ../../WINGs/wcolorpanel.c:3245 ../../WINGs/wfilepanel.c:259
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+msgid "Cancel"
+msgstr "Cancel·la"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3261 ../../WINGs/wfilepanel.c:763
+msgid "Warning"
+msgstr "Atenció"
+
+#: ../../WINGs/wcolorpanel.c:3262
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Ja existia una paleta amb aquest nom!\n"
+"\n"
+"La voleu sobreescriure?"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "No"
+msgstr "No"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "Yes"
+msgstr "Sí"
+
+#: ../../WINGs/wcolorpanel.c:3294
+#, c-format
+msgid "Couldn't rename palette %s to %s\n"
+msgstr "No s'ha pogut reanomenar la paleta %s com a %s\n"
+
+#: ../../WINGs/wcolorpanel.c:3320
+msgid "This will permanently remove the palette "
+msgstr "Això eliminarà la paleta per sempre "
+
+#: ../../WINGs/wcolorpanel.c:3323
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+".\n"
+"\n"
+"Esteu segurs que voleu eliminar aquesta paleta?"
+
+#: ../../WINGs/wcolorpanel.c:3348
+#, c-format
+msgid "Couldn't remove palette %s\n"
+msgstr "No s'ha pogut eliminar la paleta %s\n"
+
+#: ../../WINGs/wcolorpanel.c:3647
+#, c-format
+msgid "Could not open %s"
+msgstr "No s'ha pogut obrir %s"
+
+#: ../../WINGs/wcolorpanel.c:3654
+#, c-format
+msgid "Could not create %s"
+msgstr "No s'ha pogut crear %s"
+
+#: ../../WINGs/wcolorpanel.c:3665
+#, c-format
+msgid "Write error on file %s"
+msgstr "Error d'escriptura en el fitxer %s"
+
+#: ../../WINGs/wcolorpanel.c:3710
+msgid "Color Panel: Color unspecified"
+msgstr "Panell de color: Color no especificat"
+
+#: ../../WINGs/wfilepanel.c:235
+msgid "Name:"
+msgstr "Nom:"
+
+#: ../../WINGs/wfilepanel.c:332 ../../WINGs/wfilepanel.c:396
+msgid "Open"
+msgstr "Obre"
+
+#: ../../WINGs/wfilepanel.c:350 ../../WINGs/wfilepanel.c:402
+msgid "Save"
+msgstr "Desa"
+
+#: ../../WINGs/wfilepanel.c:565
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: no s'ha pogut obrir el directori %s\n"
+
+#: ../../WINGs/wfilepanel.c:583
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: no s'ha pogut determinar l'estat de %s\n"
+
+#: ../../WINGs/wfilepanel.c:650 ../../WINGs/wfilepanel.c:973
+#: ../../WINGs/wfontpanel.c:750
+msgid "Error"
+msgstr "Error"
+
+# és el nom d'un quadre de diàleg. eac
+#: ../../WINGs/wfilepanel.c:661
+msgid "Create Directory"
+msgstr "Crear directori"
+
+#: ../../WINGs/wfilepanel.c:662
+msgid "Enter directory name"
+msgstr "Entreu el nom del directori"
+
+#: ../../WINGs/wfilepanel.c:698 ../../WINGs/wfilepanel.c:737
+#: ../../WINGs/wfilepanel.c:768 ../../WINGs/wfilepanel.c:796
+msgid "Permission denied."
+msgstr "Permís denegat."
+
+#: ../../WINGs/wfilepanel.c:701
+#, c-format
+msgid "'%s' already exists."
+msgstr "\"%s\" existia prèviament."
+
+#: ../../WINGs/wfilepanel.c:704
+msgid "Path does not exist."
+msgstr "L'ubicació no existeix."
+
+#: ../../WINGs/wfilepanel.c:734 ../../WINGs/wfilepanel.c:793
+#, c-format
+msgid "'%s' does not exist."
+msgstr "\"%s\" no existeix."
+
+#: ../../WINGs/wfilepanel.c:741 ../../WINGs/wfilepanel.c:800
+msgid "Insufficient memory available."
+msgstr "No hi ha prou memòria disponible."
+
+#: ../../WINGs/wfilepanel.c:745 ../../WINGs/wfilepanel.c:804
+#, c-format
+msgid "'%s' is on a read-only filesystem."
+msgstr "\"%s\" es troba en un sistema de fitxers de només lectura."
+
+#: ../../WINGs/wfilepanel.c:748 ../../WINGs/wfilepanel.c:780
+#: ../../WINGs/wfilepanel.c:807
+#, c-format
+msgid "Can not delete '%s'."
+msgstr "No s'ha pogut eliminar \"%s\"."
+
+#: ../../WINGs/wfilepanel.c:755
+#, c-format
+msgid "Delete directory %s ?"
+msgstr "Voleu eliminar el directori %s ?"
+
+#: ../../WINGs/wfilepanel.c:759
+#, c-format
+msgid "Delete file %s ?"
+msgstr "Voleu eliminar el fitxer %s ?"
+
+#: ../../WINGs/wfilepanel.c:771
+#, c-format
+msgid "Directory '%s' does not exist."
+msgstr "El directori \"%s\" no existeix."
+
+#: ../../WINGs/wfilepanel.c:774
+#, c-format
+msgid "Directory '%s' is not empty."
+msgstr "El directori \"%s\" no està buit."
+
+#: ../../WINGs/wfilepanel.c:777
+#, c-format
+msgid "Directory '%s' is busy."
+msgstr "El directori \"%s\" es troba ocupat."
+
+#: ../../WINGs/wfilepanel.c:790
+#, c-format
+msgid "'%s' is a directory."
+msgstr "\"%s\" és un directori."
+
+#: ../../WINGs/wfilepanel.c:832
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "S'ha produït un error mentre s'explorava \"%s\"."
+
+#: ../../WINGs/wfilepanel.c:836
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "\"%s\" no és un directori."
+
+#: ../../WINGs/wfilepanel.c:973
+msgid "File does not exist."
+msgstr "El fitxer no existeix."
+
+#: ../../WINGs/wfont.c:324 ../../WINGs/wfont.c:344
+#, c-format
+msgid "could not load font %s."
+msgstr "no s'ha pogut carregar el tipus de lletra %s."
+
+#: ../../WINGs/wfont.c:375 ../../WINGs/wfont.c:420 ../../WINGs/wfont.c:475
+#: ../../WINGs/wfont.c:1337 ../../WINGs/wfont.c:1398 ../../WINGs/wfont.c:1469
+#, c-format
+msgid ""
+"Conversion to widechar failed (possible invalid multibyte sequence): '%s':"
+"(pos %d)\n"
+msgstr ""
+"Ha fallat la conversió a caràcter estès (possible seqüència no vàlida): '%"
+"s': (pos %d)\n"
+
+#. // remove warning later. or maybe not
+#: ../../WINGs/wfont.c:591 ../../WINGs/wfont.c:1568
+#, c-format
+msgid "Invalid font specification: '%s'\n"
+msgstr "Especificació de font no vàlida: \"%s\"\n"
+
+#: ../../WINGs/wfont.c:770 ../../WINGs/wfont.c:780
+#, c-format
+msgid "Invalid size specification '%s' in %s. Using default %d\n"
+msgstr ""
+"La mida \"%s\" especificada a %s no és vàlida. S'usa el valor per omissió %"
+"d\n"
+
+#: ../../WINGs/wfont.c:824
+#, c-format
+msgid "the following character sets are missing in %s:"
+msgstr "els següents conjunts de caràcters falten a %s:"
+
+#: ../../WINGs/wfont.c:830
+#, c-format
+msgid ""
+"the string \"%s\" will be used in place of any characters from those sets."
+msgstr ""
+"la cadena \"%s\" s'usarà en lloc dels caràcters d'aquests conjunts de "
+"caràcters."
+
+#. is arial a good fallback for multibyte?
+#: ../../WINGs/wfont.c:1232 ../../WINGs/wfont.c:1247
+#, c-format
+msgid "could not load font %s. Trying arial."
+msgstr "no s'ha pogut carregar el tipus de lletra %s. Provant amb \"arial\"."
+
+#: ../../WINGs/wfont.c:1239
+msgid "could not load antialiased font set. Reverting to standard font sets."
+msgstr ""
+"no s'ha pogut carregar el conjunt de fonts amb allisat. S'usarà l'estàndard."
+
+#: ../../WINGs/wfont.c:1242
+#, c-format
+msgid "could not load FontSet %s. Trying fixed."
+msgstr "no s'ha pogut carregar el tipus de lletra %s. Provant amb \"fixed\"."
+
+#: ../../WINGs/wfont.c:1254
+msgid "could not load antialiased fonts. Reverting to normal fonts."
+msgstr "no s'han pogut carregar fonts allisades. S'usaran fonts normals."
+
+#: ../../WINGs/wfont.c:1257 ../../WINGs/wfont.c:1268
+#, c-format
+msgid "could not load font %s. Trying fixed."
+msgstr "no s'ha pogut carregar la font %s. Provant amb \"fixed\"."
+
+#: ../../WINGs/wfont.c:1262
+#, c-format
+msgid "could not load font set %s. Trying fixed."
+msgstr "no s'ha pogut carregar el conjunt de fonts %s. Provant amb \"fixed\"."
+
+#: ../../WINGs/wfont.c:1272
+msgid "could not load fixed font!"
+msgstr "no s'ha pogut carregar el tipus de lletra \"fixed\" !"
+
+#: ../../WINGs/wfont.c:1520
+#, c-format
+msgid "font description %s is too large."
+msgstr "la descripció de tipus de lletra %s és massa gran."
+
+#: ../../WINGs/wfontpanel.c:235
+msgid "Test!!!"
+msgstr "Prova!!!"
+
+#: ../../WINGs/wfontpanel.c:241
+msgid "Family"
+msgstr "Familia"
+
+#: ../../WINGs/wfontpanel.c:252
+msgid "Typeface"
+msgstr "Fosa"
+
+#: ../../WINGs/wfontpanel.c:263
+msgid "Size"
+msgstr "Mida"
+
+#: ../../WINGs/wfontpanel.c:282
+msgid "Set"
+msgstr "Conjunt"
+
+#: ../../WINGs/wfontpanel.c:288
+msgid "Revert"
+msgstr "Torna"
+
+#: ../../WINGs/wfontpanel.c:751
+msgid "Could not retrieve font list"
+msgstr "No s'ha pogut obtenir la llista de tipus de lletra"
+
+#: ../../WINGs/wfontpanel.c:765
+#, c-format
+msgid "font name %s is longer than 256, which is invalid."
+msgstr ""
+"el nom de tipus de lletra %s ocupa més de 256 caràcters, per tant no és "
+"vàlid."
+
+#: ../../WINGs/wfontpanel.c:913
+msgid "Roman"
+msgstr "Romana"
+
+#: ../../WINGs/wfontpanel.c:916
+msgid "Italic"
+msgstr "Itàlica"
+
+#: ../../WINGs/wfontpanel.c:918
+msgid "Oblique"
+msgstr "Obliqua"
+
+#: ../../WINGs/wfontpanel.c:920
+msgid "Rev Italic"
+msgstr "Itàlica inv"
+
+#: ../../WINGs/wfontpanel.c:922
+msgid "Rev Oblique"
+msgstr "Obliqua inv"
+
+#: ../../WINGs/wfontpanel.c:928
+msgid "Normal"
+msgstr "Normal"
+
+#: ../../WINGs/widgets.c:419
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: no s'ha pogut carregar el fitxer d'imatges: %s"
+
+#: ../../WINGs/widgets.c:772
+msgid ""
+"could not load any fonts. Make sure your font installation and locale "
+"settings are correct."
+msgstr ""
+"no s'ha pogut carregar cap font. Assegureu-vos que heu instal·lat i "
+"configurat correctament les fonts i el local."
+
+#: ../../WINGs/wruler.c:192
+msgid "0   inches"
+msgstr "0   polzades"
+
+#~ msgid ""
+#~ "Text antialiasing is enabled in the configuration but the X server "
+#~ "doesn't have the required capabilities (missing RENDER extension). "
+#~ "Disabling text antialiasing."
+#~ msgstr ""
+#~ "L'allisat de text està habilitat a la configuració però el servidor X no\n"
+#~ "té la capacitat necessària (falta l'extensió RENDER) de manera que "
+#~ "l'allisat\n"
+#~ "de text es deshabilitarà."

bazel/WINGs/po/cs.po

@@ -0,0 +1,663 @@
+# Czech messages for WINGs
+# (C) 2001 Jiří Hnídek
+# Special thanks to Jan "judas" Tomka
+#
+# Original translation by Jiří Hnídek on Oct 11 2001
+# Currently maintained by Jiří Hnídek <jiri.hnidek@vslib.cz>
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: WINGs 0.70.0\n"
+"POT-Creation-Date: 2001-10-11 19:10+0100\n"
+"PO-Revision-Date: 2001-10-11 22:00+0100\n"
+"Last-Translator: Jiří Hnídek <jiri.hnidek@vslib.cz>\n"
+"Language-Team: Czech <cz@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: unknown\n"
+
+#: ../../WINGs/connection.c:451 ../../WINGs/connection.c:516
+#: ../../WINGs/connection.c:559
+msgid "Bad address-service-protocol combination"
+msgstr "Nesprávná kombinace adresa-služba-protokol"
+
+#: ../../WINGs/dragsource.c:541
+msgid "XDND selection lost during drag operation..."
+msgstr "XDND výběr se ztratil během opere táhnutí..."
+
+#: ../../WINGs/dragsource.c:610
+#, c-format
+msgid "drag & drop timed out while waiting for response from 0x%x\n"
+msgstr "čas pro drag & drop vypršel během čekání na odpoveď z 0x%x\n"
+
+#: ../../WINGs/dragsource.c:728
+msgid "could not get ownership of XDND selection"
+msgstr "nemožné získat vlastnictví nebo XDND výběr"
+
+#: ../../WINGs/dragsource.c:898
+#, c-format
+msgid "drag source received unexpected XdndFinished message from %x"
+msgstr "zdroj tahání přijal neočekávanou zprávu XdndFinished z %x"
+
+#: ../../WINGs/dragsource.c:1040
+#, c-format
+msgid "unknown XDND action %s from 0x%x"
+msgstr "neznámá XDND akce %s z 0x%x"
+
+#: ../../WINGs/dragsource.c:1073
+msgid "received invalid drag & drop type list"
+msgstr "přijatý nesprávný seznam typů drag & drop"
+
+#: ../../WINGs/dragsource.c:1161
+msgid "received Enter event in bad order"
+msgstr "přijatá událost Enter v nesprávném pořadí"
+
+#: ../../WINGs/dragsource.c:1168
+#, c-format
+msgid "received drag & drop request with unsupported version %i"
+msgstr "přijatý požadavek drag & drop s nepodporovanou verzí %i"
+
+#: ../../WINGs/error.c:56
+#, c-format
+msgid "Unknown error %d"
+msgstr "Neznámá chyba %d"
+
+#: ../../WINGs/error.c:61
+#, c-format
+msgid "Error %d"
+msgstr "Chyba %d"
+
+#: ../../WINGs/error.c:112
+msgid "warning: "
+msgstr "varovíní: "
+
+#: ../../WINGs/error.c:139
+msgid "fatal: "
+msgstr "fatální chyba: "
+
+#: ../../WINGs/error.c:165 ../../WINGs/error.c:194
+msgid "error: "
+msgstr "chyba: "
+
+#: ../../WINGs/findfile.c:50
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "nemožné zjistit informaci o UID %i"
+
+#: ../../WINGs/findfile.c:68
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "nemožné zjistit informaci o uživatelovi %s"
+
+#: ../../WINGs/hashtable.c:275
+msgid "rebuilding hash table...\n"
+msgstr "přepis tabulky hashovských funkcí...\n"
+
+#: ../../WINGs/hashtable.c:279
+msgid "finished rebuild.\n"
+msgstr "konec přepisu.\n"
+
+#: ../../WINGs/host.c:116
+msgid "Cannot get current host name"
+msgstr "Nemožné zjistit aktuální jméno počítače"
+
+#: ../../WINGs/memory.c:94
+msgid "malloc() failed. Retrying after 2s."
+msgstr "chyba malloc(). Nový pokus o 2s."
+
+#: ../../WINGs/memory.c:103
+msgid "Really Bad Error: recursive malloc() failure."
+msgstr "Skutečně ošklivá chyba: rekurzivní chyba malloc()."
+
+#: ../../WINGs/memory.c:106 ../../WINGs/memory.c:146
+msgid "virtual memory exhausted"
+msgstr "virtuální paměť vyčerpaná"
+
+#: ../../WINGs/memory.c:133
+msgid "realloc() failed. Retrying after 2s."
+msgstr "chyba realloc(). Nový pokus o 2s."
+
+#: ../../WINGs/memory.c:142
+msgid "Really Bad Error: recursive realloc() failure."
+msgstr "Skutečně ošklivá chyba: rekurzivní chyba realloc()."
+
+#: ../../WINGs/memory.c:205
+#, c-format
+msgid "trying to release unexisting data %p"
+msgstr "pokus uvolnit neexistujícá data %p"
+
+#: ../../WINGs/memory.c:210
+#, c-format
+msgid "RELEASING %p\n"
+msgstr "UVOLNĚNÍ %p\n"
+
+#: ../../WINGs/wcolor.c:198 ../../WINGs/wcolor.c:211 ../../WINGs/wcolor.c:250
+#: ../../WINGs/wcolor.c:291
+#, c-format
+msgid "could not allocate %s color"
+msgstr "nemožné alokovat %s barvu"
+
+#: ../../WINGs/wcolor.c:198
+msgid "white"
+msgstr "bílou"
+
+#: ../../WINGs/wcolor.c:211
+msgid "black"
+msgstr "černou"
+
+#: ../../WINGs/wcolor.c:250
+msgid "gray"
+msgstr "šedou"
+
+#: ../../WINGs/wcolor.c:291
+msgid "dark gray"
+msgstr "tmavě šedou"
+
+#: ../../WINGs/wcolorpanel.c:410
+msgid "Colors"
+msgstr "Barvy"
+
+#: ../../WINGs/wcolorpanel.c:600 ../../WINGs/wcolorpanel.c:2819
+msgid "Brightness"
+msgstr "Světlost"
+
+#: ../../WINGs/wcolorpanel.c:602 ../../WINGs/wcolorpanel.c:678
+#: ../../WINGs/wcolorpanel.c:711 ../../WINGs/wcolorpanel.c:745
+#: ../../WINGs/wcolorpanel.c:805 ../../WINGs/wcolorpanel.c:839
+#: ../../WINGs/wcolorpanel.c:873 ../../WINGs/wcolorpanel.c:908
+#: ../../WINGs/wcolorpanel.c:2159 ../../WINGs/wcolorpanel.c:2821
+#: ../../WINGs/wcolorpanel.c:2857 ../../WINGs/wcolorpanel.c:2893
+#: ../../WINGs/wcolorpanel.c:3741
+msgid "Color Panel: Could not allocate memory"
+msgstr "Panel barev: Nemožné alokovat paměť"
+
+#: ../../WINGs/wcolorpanel.c:675 ../../WINGs/wcolorpanel.c:676
+msgid "Red"
+msgstr "Červená"
+
+#: ../../WINGs/wcolorpanel.c:708 ../../WINGs/wcolorpanel.c:709
+msgid "Green"
+msgstr "Zelená"
+
+#: ../../WINGs/wcolorpanel.c:742 ../../WINGs/wcolorpanel.c:743
+msgid "Blue"
+msgstr "Modrá"
+
+#: ../../WINGs/wcolorpanel.c:802 ../../WINGs/wcolorpanel.c:803
+msgid "Cyan"
+msgstr ""
+
+#: ../../WINGs/wcolorpanel.c:836 ../../WINGs/wcolorpanel.c:837
+msgid "Magenta"
+msgstr ""
+
+#: ../../WINGs/wcolorpanel.c:870 ../../WINGs/wcolorpanel.c:871
+msgid "Yellow"
+msgstr "Žlutá"
+
+#: ../../WINGs/wcolorpanel.c:905 ../../WINGs/wcolorpanel.c:906
+msgid "Black"
+msgstr "Černá"
+
+#: ../../WINGs/wcolorpanel.c:986
+msgid "Spectrum"
+msgstr "Spektrum"
+
+#: ../../WINGs/wcolorpanel.c:1016
+msgid "Palette"
+msgstr "Paleta"
+
+#: ../../WINGs/wcolorpanel.c:1022
+msgid "New from File..."
+msgstr "Nová ze souboru..."
+
+#: ../../WINGs/wcolorpanel.c:1023 ../../WINGs/wcolorpanel.c:1071
+#: ../../WINGs/wcolorpanel.c:1088
+msgid "Rename..."
+msgstr "Přejmenovat..."
+
+#: ../../WINGs/wcolorpanel.c:1024 ../../WINGs/wcolorpanel.c:1072
+#: ../../WINGs/wcolorpanel.c:1089 ../../WINGs/wcolorpanel.c:3316
+msgid "Remove"
+msgstr "Odstranit"
+
+#: ../../WINGs/wcolorpanel.c:1025
+msgid "Copy"
+msgstr "Kopírovat"
+
+#: ../../WINGs/wcolorpanel.c:1026
+msgid "New from Clipboard"
+msgstr "Nová ze schránky"
+
+#: ../../WINGs/wcolorpanel.c:1047
+msgid "X11-Colors"
+msgstr "Barvy X11"
+
+#: ../../WINGs/wcolorpanel.c:1064
+msgid "Color"
+msgstr "Barva"
+
+#: ../../WINGs/wcolorpanel.c:1070
+msgid "Add..."
+msgstr "Přidat..."
+
+#: ../../WINGs/wcolorpanel.c:1080
+msgid "List"
+msgstr "Seznam"
+
+#: ../../WINGs/wcolorpanel.c:1087
+msgid "New..."
+msgstr "Nový..."
+
+#: ../../WINGs/wcolorpanel.c:1226
+#, c-format
+msgid ""
+"Color Panel: Could not create directory %s needed to store configurations"
+msgstr ""
+"Panel barev: Nemožné vytvořit adresář %s potřebný k uložení nastavení"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1232 ../../WINGs/wcolorpanel.c:3202
+#: ../../WINGs/wcolorpanel.c:3206
+msgid "File Error"
+msgstr "Chyba souboru"
+
+#: ../../WINGs/wcolorpanel.c:1233
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Nemožné vytvořit konfigurační adresář panelu barev"
+
+#: ../../WINGs/wcolorpanel.c:1234 ../../WINGs/wcolorpanel.c:3203
+#: ../../WINGs/wcolorpanel.c:3208 ../../WINGs/wcolorpanel.c:3235
+#: ../../WINGs/wfilepanel.c:243 ../../WINGs/wfilepanel.c:641
+#: ../../WINGs/wfilepanel.c:653 ../../WINGs/wfilepanel.c:752
+#: ../../WINGs/wfilepanel.c:963 ../../WINGs/wfontpanel.c:717
+msgid "OK"
+msgstr "OK"
+
+#: ../../WINGs/wcolorpanel.c:1240 ../../WINGs/wcolorpanel.c:1276
+#: ../../WINGs/wcolorpanel.c:1294
+msgid "Color Panel: Could not find file"
+msgstr "Panel barev: Nemožné nalézt soubor"
+
+#: ../../WINGs/wcolorpanel.c:1481 ../../WINGs/wcolorpanel.c:1546
+#: ../../WINGs/wcolorpanel.c:1610
+msgid "Color Panel: X failed request"
+msgstr "Panel barev: chyba požadavku X"
+
+#: ../../WINGs/wcolorpanel.c:2855
+msgid "Saturation"
+msgstr "Saturace"
+
+#: ../../WINGs/wcolorpanel.c:2891
+msgid "Hue"
+msgstr "Odteď"
+
+#: ../../WINGs/wcolorpanel.c:3141
+msgid "Open Palette"
+msgstr "Otevřít paletu"
+
+#: ../../WINGs/wcolorpanel.c:3203
+msgid "Invalid file format !"
+msgstr "Nesprávný souborový formát!"
+
+#: ../../WINGs/wcolorpanel.c:3205
+#, c-format
+msgid "can't remove file %s"
+msgstr "nemožné odstranit soubor %s"
+
+#: ../../WINGs/wcolorpanel.c:3207
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Nemožné odstranit soubor z konfiguračního adresáře!"
+
+#: ../../WINGs/wcolorpanel.c:3234
+msgid "Rename"
+msgstr "Přejmenovat"
+
+#: ../../WINGs/wcolorpanel.c:3234
+msgid "Rename palette to:"
+msgstr "Přejmenovat paletu:"
+
+#: ../../WINGs/wcolorpanel.c:3235 ../../WINGs/wfilepanel.c:252
+#: ../../WINGs/wfilepanel.c:653 ../../WINGs/wfilepanel.c:752
+msgid "Cancel"
+msgstr "Zrušit"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3251 ../../WINGs/wfilepanel.c:752
+msgid "Warning"
+msgstr "Varování"
+
+#: ../../WINGs/wcolorpanel.c:3252
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Paleta už existuje!\n"
+"\n"
+"Přepsat?"
+
+#: ../../WINGs/wcolorpanel.c:3252 ../../WINGs/wcolorpanel.c:3316
+msgid "No"
+msgstr "Ne"
+
+#: ../../WINGs/wcolorpanel.c:3252 ../../WINGs/wcolorpanel.c:3316
+msgid "Yes"
+msgstr "Ano"
+
+#: ../../WINGs/wcolorpanel.c:3284
+#, c-format
+msgid "Couldn't rename palette %s to %s\n"
+msgstr "Nemožné přejmenovat paletu %s na %s\n"
+
+#: ../../WINGs/wcolorpanel.c:3310
+msgid "This will permanently remove the palette "
+msgstr "Paleta bude natrvalo smazaná"
+
+#: ../../WINGs/wcolorpanel.c:3313
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+".\n"
+"\n"
+"Jste si jisti, že chcete odstranit tuto paletu?"
+
+#: ../../WINGs/wcolorpanel.c:3338
+#, c-format
+msgid "Couldn't remove palette %s\n"
+msgstr "Nemožné odstranit paletu %s\n"
+
+#: ../../WINGs/wcolorpanel.c:3643
+#, c-format
+msgid "Could not open %s"
+msgstr "Nemožné otevřít %s"
+
+#: ../../WINGs/wcolorpanel.c:3650
+#, c-format
+msgid "Could not create %s"
+msgstr "Nemožné vytvořit %s"
+
+#: ../../WINGs/wcolorpanel.c:3661
+#, c-format
+msgid "Write error on file %s"
+msgstr "Chyba při zápisu do souboru %s"
+
+#: ../../WINGs/wcolorpanel.c:3706
+msgid "Color Panel: Color unspecified"
+msgstr "Panel barev: Nespecifikovaná barva"
+
+#: ../../WINGs/wfilepanel.c:228
+msgid "Name:"
+msgstr "Jméno:"
+
+#: ../../WINGs/wfilepanel.c:325 ../../WINGs/wfilepanel.c:390
+msgid "Open"
+msgstr "Otevřít"
+
+#: ../../WINGs/wfilepanel.c:343 ../../WINGs/wfilepanel.c:396
+msgid "Save"
+msgstr "Uložit"
+
+#: ../../WINGs/wfilepanel.c:556
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: nemožné otevřít adresář %s\n"
+
+#: ../../WINGs/wfilepanel.c:574
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: nemožné zjistit informace o %s\n"
+
+#: ../../WINGs/wfilepanel.c:641 ../../WINGs/wfilepanel.c:962
+#: ../../WINGs/wfontpanel.c:716
+msgid "Error"
+msgstr "Chyba"
+
+#: ../../WINGs/wfilepanel.c:652
+msgid "Create Directory"
+msgstr "Vytvořit adresář"
+
+#: ../../WINGs/wfilepanel.c:653
+msgid "Enter directory name"
+msgstr "Jméno adresáře"
+
+#: ../../WINGs/wfilepanel.c:689 ../../WINGs/wfilepanel.c:728
+#: ../../WINGs/wfilepanel.c:757 ../../WINGs/wfilepanel.c:785
+msgid "Permission denied."
+msgstr "Přístup odmítnut."
+
+#: ../../WINGs/wfilepanel.c:692
+#, c-format
+msgid "'%s' already exists."
+msgstr "'%s' už existuje"
+
+#: ../../WINGs/wfilepanel.c:695
+msgid "Path does not exist."
+msgstr "Cesta neexistuje."
+
+#: ../../WINGs/wfilepanel.c:725 ../../WINGs/wfilepanel.c:782
+#, c-format
+msgid "'%s' does not exist."
+msgstr "'%s' neexistuje."
+
+#: ../../WINGs/wfilepanel.c:732 ../../WINGs/wfilepanel.c:789
+msgid "Insufficient memory available."
+msgstr "Nedostatek paměti."
+
+#: ../../WINGs/wfilepanel.c:736 ../../WINGs/wfilepanel.c:793
+#, c-format
+msgid "'%s' is on a read-only filesystem."
+msgstr "'%s' je na souborovém systému jen pro čtení."
+
+#: ../../WINGs/wfilepanel.c:739 ../../WINGs/wfilepanel.c:769
+#: ../../WINGs/wfilepanel.c:796
+#, c-format
+msgid "Can not delete '%s'."
+msgstr "Nemožné odstranit '%s'."
+
+#: ../../WINGs/wfilepanel.c:745
+#, c-format
+msgid "Delete directory %s ?"
+msgstr "Odstranit adresář %s?"
+
+#: ../../WINGs/wfilepanel.c:748
+#, c-format
+msgid "Delete file %s ?"
+msgstr "Odstranit soubor %s?"
+
+#: ../../WINGs/wfilepanel.c:760
+#, c-format
+msgid "Directory '%s' does not exist."
+msgstr "Adresář '%s' neexistuje."
+
+#: ../../WINGs/wfilepanel.c:763
+#, c-format
+msgid "Directory '%s' is not empty."
+msgstr "Adresář '%s' není prázdný."
+
+#: ../../WINGs/wfilepanel.c:766
+#, c-format
+msgid "Directory '%s' is busy."
+msgstr "Adresář '%s' je používaný."
+
+#: ../../WINGs/wfilepanel.c:779
+#, c-format
+msgid "'%s' is a directory."
+msgstr "'%s' je adresář."
+
+#: ../../WINGs/wfilepanel.c:821
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Při prohlížení '%s' nastala chyba."
+
+#: ../../WINGs/wfilepanel.c:825
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "'%s' není adresář."
+
+#: ../../WINGs/wfilepanel.c:962
+msgid "File does not exist."
+msgstr "Soubor neexistuje."
+
+#: ../../WINGs/wfont.c:129
+#, c-format
+msgid "the following character sets are missing in %s:"
+msgstr "nasledující sady znaků chybí v %s:"
+
+#: ../../WINGs/wfont.c:136
+#, c-format
+msgid ""
+"the string \"%s\" will be used in place of any characters from those sets."
+msgstr ""
+"řetězec \"%s\" bude použitý namísto znaků z těchto sad."
+
+#: ../../WINGs/wfont.c:282 ../../WINGs/wfont.c:318
+#, c-format
+msgid "could not load font set %s. Trying fixed."
+msgstr "nemožné načíst font %s. Zkouší se načíst fixed."
+
+#: ../../WINGs/wfont.c:288 ../../WINGs/wfont.c:324
+#, c-format
+msgid "could not load font %s. Trying fixed."
+msgstr "nemožno načíst font %s. Zkoší se načíst fixed."
+
+#: ../../WINGs/wfont.c:292 ../../WINGs/wfont.c:328
+msgid "could not load fixed font!"
+msgstr "nemožné načíst font fixed!"
+
+#: ../../WINGs/wfont.c:423
+#, c-format
+msgid "font description %s is too large."
+msgstr "popis fontu %s je příliš velký."
+
+#: ../../WINGs/wfontpanel.c:205
+msgid "Test!!!"
+msgstr "Zkouška!!!"
+
+#: ../../WINGs/wfontpanel.c:211
+msgid "Family"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:222
+msgid "Typeface"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:233
+msgid "Size"
+msgstr "Velikost"
+
+#: ../../WINGs/wfontpanel.c:252
+msgid "Set"
+msgstr "Sada"
+
+#: ../../WINGs/wfontpanel.c:257
+msgid "Revert"
+msgstr "Zpět"
+
+#: ../../WINGs/wfontpanel.c:717
+msgid "Could not retrieve font list"
+msgstr "Nemožné obdržet seznam fontů"
+
+#: ../../WINGs/wfontpanel.c:729
+#, c-format
+msgid "font name %s is longer than 256, which is invalid."
+msgstr "jméno fontu %s je delší než 256, což je špatně."
+
+#: ../../WINGs/wfontpanel.c:880
+msgid "Roman"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:883
+msgid "Italic"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:885
+msgid "Oblique"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:887
+msgid "Rev Italic"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:889
+msgid "Rev Oblique"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:895
+msgid "Normal"
+msgstr "Normílní"
+
+#: ../../WINGs/widgets.c:414
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: nemožné načíst soubor s obrázky pro widgety: %s"
+
+#: ../../WINGs/widgets.c:525
+#, c-format
+msgid "WINGs: could not open display %s"
+msgstr "WINGs: nemožné otevřít display %s"
+
+#: ../../WINGs/widgets.c:717
+msgid ""
+"could not load any fonts. Make sure your font installationand locale "
+"settings are correct."
+msgstr ""
+"nemožné načíst žádný font. Ubezpečte se, že instalace fontů a místního "
+"nastavení jsou v pořádku."
+
+#: ../../WINGs/wruler.c:189
+msgid "0   inches"
+msgstr "0    palců"
+
+#: ../../WINGs/wtext.c:1212
+msgid "...for this app will surely crash :-)\n"
+msgstr "...pro tuto aplikaci to určitě spadne :-)\n"
+
+#: ../../WINGs/wtext.c:2084
+msgid "didn't get it\n"
+msgstr "nedosaženo\n"
+
+#: ../../WINGs/wtext.c:2726
+#, c-format
+msgid "type is [%s]\n"
+msgstr "typ je [%s]\n"
+
+#: ../../WINGs/wtext.c:2797
+msgid "could not request data for dropped data"
+msgstr "nemohou být vyžádána data pro položená data"
+
+#: ../../WINGs/wtext.c:2995
+msgid "could not create text's view\n"
+msgstr "nemožné zobrazit text\n"
+
+#: ../../WINGs/wview.c:219
+msgid "trying to realize widget of unrealized parent"
+msgstr "snaha vytvořit widget neexistujícího rodiče objektu"
+
+#: ../../WINGs/wview.c:267
+msgid "trying to reparent realized view to unrealized parent"
+msgstr ""
+
+#: ../../WINGs/wtextfield.c:490
+msgid "only left alignment is supported in textfields"
+msgstr "pro textové pole je povolené jen levé zarovnání"
+
+#pozor, co je STRING?
+#: ../../WINGs/wwindow.c:222
+msgid "window title conversion error... using STRING encoding"
+msgstr "chyba konverze titulku okna... použije se kódovaní STRING"
+
+#: ../../WINGs/wwindow.c:313
+msgid "could not allocate memory for window size hints"
+msgstr "nemožné alokovat paměť pro pokyny velikosti okna"
+
+#: ../../WINGs/wwindow.c:586
+msgid "could not allocate memory for WM hints"
+msgstr "nemožné alokovat paměť pro pokyny WM"
+
+#: ../../WINGs/wwindow.c:627
+msgid "icon title conversion error..using STRING encoding"
+msgstr "chyba konverze titulku ikony... použije se kódovaní STRING"
+

bazel/WINGs/po/de.po

@@ -0,0 +1,627 @@
+#
+# German Message Catalog for WINGs
+#
+# Initial translation
+#   Gudio Scholz <guido.scholz@bayernline.de>
+#
+# Adapted to versions 0.80 ff.
+#   Torsten Marek <shlomme@gmx.net>
+#
+
+msgid ""
+msgstr ""
+"Project-Id-Version: WINGs\n"
+"POT-Creation-Date: 2004-11-01 16:24+0100\n"
+"PO-Revision-Date: 2004-11-05 23:48+0100\n"
+"Last-Translator: shlomme@gmx.net\n"
+"Language-Team: German\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../../WINGs/connection.c:471 ../../WINGs/connection.c:536
+#: ../../WINGs/connection.c:579
+msgid "Bad address-service-protocol combination"
+msgstr "Ungültige Kombination von Adresse und Dienstprotokoll"
+
+#: ../../WINGs/error.c:54
+#, c-format
+msgid "Unknown error %d"
+msgstr "Unbekannter Fehler %d"
+
+#: ../../WINGs/error.c:59
+#, c-format
+msgid "Error %d"
+msgstr "Fehler %d"
+
+#: ../../WINGs/error.c:110
+msgid "warning: "
+msgstr "warnung: "
+
+#: ../../WINGs/error.c:137
+msgid "fatal: "
+msgstr "fataler Fehler: "
+
+#: ../../WINGs/error.c:163 ../../WINGs/error.c:192
+msgid "error: "
+msgstr "fehler: "
+
+#: ../../WINGs/findfile.c:48
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "Passworteintrag für UID %i konnte nicht ermittelt werden"
+
+#: ../../WINGs/findfile.c:66
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "Passworteintrag für Benutzer %s konnte nicht ermittelt werden"
+
+#: ../../WINGs/host.c:114
+msgid "Cannot get current host name"
+msgstr "Aktueller Hostname kann nicht ermittelt werden"
+
+#: ../../WINGs/proplist.c:91
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "Syntaxfehler in %s %s, Zeile %i: %s"
+
+#: ../../WINGs/proplist.c:150
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr ""
+"Nur Zeichenketten oder Binärdaten werden als Schlüssel für ein PropList-Dictionary "
+"unterstützt"
+
+#: ../../WINGs/proplist.c:184 ../../WINGs/proplist.c:236
+#: ../../WINGs/proplist.c:394 ../../WINGs/proplist.c:474
+#: ../../WINGs/proplist.c:1075 ../../WINGs/proplist.c:1127
+#: ../../WINGs/proplist.c:1293 ../../WINGs/proplist.c:1372
+#: ../../WINGs/proplist.c:1493 ../../WINGs/proplist.c:1540
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr "PropList-Funktionen werden auf nicht-WMPropList-Objekte angewendet"
+
+#: ../../WINGs/proplist.c:630
+msgid "unterminated PropList string"
+msgstr "nicht terminierte PropList-Zeichenkette"
+
+#: ../../WINGs/proplist.c:670
+msgid "unterminated PropList data"
+msgstr "nicht terminierte PropList-Binärdaten"
+
+#: ../../WINGs/proplist.c:678
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr "nicht terminierte PropList-Binärdaten (fehlendes Hex-Zeichen)"
+
+#: ../../WINGs/proplist.c:690 ../../WINGs/proplist.c:695
+msgid "non hexdigit character in PropList data"
+msgstr "falsches Hex-Zeichen in PropList-Binärdaten"
+
+#: ../../WINGs/proplist.c:729
+msgid "unterminated PropList array"
+msgstr "nicht terminiertes PropList-Array"
+
+#: ../../WINGs/proplist.c:737
+msgid "missing or unterminated PropList array"
+msgstr "fehlendes oder nicht terminiertes PropList-Array"
+
+#: ../../WINGs/proplist.c:747
+msgid "could not get PropList array element"
+msgstr "PropList-Array-Element konnte nicht gelesen werden"
+
+#: ../../WINGs/proplist.c:776
+msgid "unterminated PropList dictionary"
+msgstr "nicht terminiertes PropList-Dictionary"
+
+#: ../../WINGs/proplist.c:793
+msgid "missing PropList dictionary key"
+msgstr "fehlender Schlüssel in PropList-Dictionary"
+
+#: ../../WINGs/proplist.c:795
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr "fehlender Schlüssel in PropList-Dictionary oder fehlende Terminierung"
+
+#: ../../WINGs/proplist.c:803
+msgid "error parsing PropList dictionary key"
+msgstr "Fehler beim Parsen eines PropList-Dictionary-Schlüssels"
+
+#: ../../WINGs/proplist.c:811
+msgid "missing = in PropList dictionary entry"
+msgstr "fehlendes \"=\" in PropList-Dictionary-Schlüssel"
+
+#: ../../WINGs/proplist.c:819
+msgid "error parsing PropList dictionary entry value"
+msgstr "Fehler beim Parsen eines PropList-Dictionary-Wertes"
+
+#: ../../WINGs/proplist.c:827
+msgid "missing ; in PropList dictionary entry"
+msgstr "fehlendes \";\" in PropList-Dictionary-Eintrag"
+
+#: ../../WINGs/proplist.c:888
+msgid ""
+"was expecting a string, data, array or dictionary. If it's a string, try "
+"enclosing it with \"."
+msgstr ""
+"Zeichenkette, Binärdaten, Array oder Dictionary erwartet. Zeichenketten ggf. mit \" "
+"einklammern."
+
+#: ../../WINGs/proplist.c:892
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "Kommentare sind in Domänendaten von WindowMaker nicht erlaubt."
+
+#: ../../WINGs/proplist.c:1563 ../../WINGs/proplist.c:1630
+msgid "extra data after end of property list"
+msgstr "zusätzliche Daten hinter dem Ende der Propertyliste"
+
+#: ../../WINGs/proplist.c:1606
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "Dateigröße von '%s' konnte nicht ermittelt werden"
+
+#: ../../WINGs/proplist.c:1619
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "Fehler beim Lesen der Datei '%s'"
+
+#: ../../WINGs/proplist.c:1671
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "mkstemp (%s) fehlgeschlagen"
+
+#: ../../WINGs/proplist.c:1682
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "mktemp (%s) fehlgeschlagen"
+
+#: ../../WINGs/proplist.c:1693
+#, c-format
+msgid "open (%s) failed"
+msgstr "open (%s) fehlgeschlagen"
+
+#: ../../WINGs/proplist.c:1700
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "Schreiben in Datei: %s fehlgeschlagen"
+
+#: ../../WINGs/proplist.c:1708
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "fclose (%s) fehlgeschlagen"
+
+#: ../../WINGs/proplist.c:1717
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "rename ('%s' nach '%s') fehlgeschlagen"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:188 ../../WINGs/userdefaults.c:204
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "Bei der Synchronisation konnte nicht aus der Datei '%s' gelesen werden"
+
+#: ../../WINGs/wcolor.c:237 ../../WINGs/wcolor.c:249 ../../WINGs/wcolor.c:288
+#: ../../WINGs/wcolor.c:329
+#, c-format
+msgid "could not allocate %s color"
+msgstr "Farbe %s konnte nicht erzeugt werden"
+
+#: ../../WINGs/wcolor.c:237
+msgid "white"
+msgstr "Weiß"
+
+#: ../../WINGs/wcolor.c:249
+msgid "black"
+msgstr "Schwarz"
+
+#: ../../WINGs/wcolor.c:288
+msgid "gray"
+msgstr "Grau"
+
+#: ../../WINGs/wcolor.c:329
+msgid "dark gray"
+msgstr "Dunkelgrau"
+
+#: ../../WINGs/wcolorpanel.c:420
+msgid "Colors"
+msgstr "Farben"
+
+#: ../../WINGs/wcolorpanel.c:610 ../../WINGs/wcolorpanel.c:2829
+msgid "Brightness"
+msgstr "Helligkeit"
+
+#: ../../WINGs/wcolorpanel.c:612 ../../WINGs/wcolorpanel.c:688
+#: ../../WINGs/wcolorpanel.c:721 ../../WINGs/wcolorpanel.c:755
+#: ../../WINGs/wcolorpanel.c:815 ../../WINGs/wcolorpanel.c:849
+#: ../../WINGs/wcolorpanel.c:883 ../../WINGs/wcolorpanel.c:918
+#: ../../WINGs/wcolorpanel.c:2169 ../../WINGs/wcolorpanel.c:2831
+#: ../../WINGs/wcolorpanel.c:2867 ../../WINGs/wcolorpanel.c:2903
+#: ../../WINGs/wcolorpanel.c:3745
+msgid "Color Panel: Could not allocate memory"
+msgstr "Farb-Panel: Speicher konnte nicht reserviert werden"
+
+#: ../../WINGs/wcolorpanel.c:685 ../../WINGs/wcolorpanel.c:686
+msgid "Red"
+msgstr "Rot"
+
+#: ../../WINGs/wcolorpanel.c:718 ../../WINGs/wcolorpanel.c:719
+msgid "Green"
+msgstr "Grün"
+
+#: ../../WINGs/wcolorpanel.c:752 ../../WINGs/wcolorpanel.c:753
+msgid "Blue"
+msgstr "Blau"
+
+#: ../../WINGs/wcolorpanel.c:812 ../../WINGs/wcolorpanel.c:813
+msgid "Cyan"
+msgstr ""
+
+#: ../../WINGs/wcolorpanel.c:846 ../../WINGs/wcolorpanel.c:847
+msgid "Magenta"
+msgstr ""
+
+#: ../../WINGs/wcolorpanel.c:880 ../../WINGs/wcolorpanel.c:881
+msgid "Yellow"
+msgstr "Gelb"
+
+#: ../../WINGs/wcolorpanel.c:915 ../../WINGs/wcolorpanel.c:916
+msgid "Black"
+msgstr "Schwarz"
+
+#: ../../WINGs/wcolorpanel.c:996
+msgid "Spectrum"
+msgstr "Spektrum"
+
+#: ../../WINGs/wcolorpanel.c:1026
+msgid "Palette"
+msgstr ""
+
+#: ../../WINGs/wcolorpanel.c:1032
+msgid "New from File..."
+msgstr "Neu aus Datei..."
+
+#: ../../WINGs/wcolorpanel.c:1033 ../../WINGs/wcolorpanel.c:1081
+#: ../../WINGs/wcolorpanel.c:1098
+msgid "Rename..."
+msgstr "Umbenennen..."
+
+#: ../../WINGs/wcolorpanel.c:1034 ../../WINGs/wcolorpanel.c:1082
+#: ../../WINGs/wcolorpanel.c:1099 ../../WINGs/wcolorpanel.c:3326
+msgid "Remove"
+msgstr "Entfernen"
+
+#: ../../WINGs/wcolorpanel.c:1035
+msgid "Copy"
+msgstr "Kopieren"
+
+#: ../../WINGs/wcolorpanel.c:1036
+msgid "New from Clipboard"
+msgstr "Neu aus Zwischenablage"
+
+#: ../../WINGs/wcolorpanel.c:1057
+msgid "X11-Colors"
+msgstr "X11-Farben"
+
+#: ../../WINGs/wcolorpanel.c:1074
+msgid "Color"
+msgstr "Farbe"
+
+#: ../../WINGs/wcolorpanel.c:1080
+msgid "Add..."
+msgstr "Hinzufügen..."
+
+#: ../../WINGs/wcolorpanel.c:1090
+msgid "List"
+msgstr "Liste"
+
+#: ../../WINGs/wcolorpanel.c:1097
+msgid "New..."
+msgstr "Neu..."
+
+#: ../../WINGs/wcolorpanel.c:1236
+#, c-format
+msgid "Color Panel: Could not create directory %s needed to store configurations"
+msgstr "Farb-Panel: Verzeichnis %s konnte zum Speichern der Konfiguration nicht erzeugt werden"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1242 ../../WINGs/wcolorpanel.c:3212
+#: ../../WINGs/wcolorpanel.c:3216
+msgid "File Error"
+msgstr "Dateifehler"
+
+#: ../../WINGs/wcolorpanel.c:1243
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Konfigurationsverzeichnis für Farb-Panel konnte nicht erzeugt werden"
+
+#: ../../WINGs/wcolorpanel.c:1244 ../../WINGs/wcolorpanel.c:3213
+#: ../../WINGs/wcolorpanel.c:3218 ../../WINGs/wcolorpanel.c:3245
+#: ../../WINGs/wfilepanel.c:250 ../../WINGs/wfilepanel.c:650
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+#: ../../WINGs/wfilepanel.c:974 ../../WINGs/wfontpanel.c:591
+msgid "OK"
+msgstr ""
+
+#: ../../WINGs/wcolorpanel.c:1250 ../../WINGs/wcolorpanel.c:1286
+#: ../../WINGs/wcolorpanel.c:1304
+msgid "Color Panel: Could not find file"
+msgstr "Farb-Panel: Datei konnte nicht gefunden werden"
+
+#: ../../WINGs/wcolorpanel.c:1491 ../../WINGs/wcolorpanel.c:1556
+#: ../../WINGs/wcolorpanel.c:1620
+msgid "Color Panel: X failed request"
+msgstr "Farb-Panel: X-Anfrage fehlgeschlagen"
+
+#: ../../WINGs/wcolorpanel.c:2865
+msgid "Saturation"
+msgstr "Sättigung"
+
+#: ../../WINGs/wcolorpanel.c:2901
+msgid "Hue"
+msgstr "Farbton"
+
+#: ../../WINGs/wcolorpanel.c:3151
+msgid "Open Palette"
+msgstr "Palette öffnen"
+
+#: ../../WINGs/wcolorpanel.c:3213
+msgid "Invalid file format !"
+msgstr "Ungültiges Dateiformat!"
+
+#: ../../WINGs/wcolorpanel.c:3215
+#, c-format
+msgid "can't remove file %s"
+msgstr "Datei %s konnte nicht entfert werden"
+
+#: ../../WINGs/wcolorpanel.c:3217
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Datei konnte nicht aus Konfigurationsverzeichnis entfernt werden!"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename"
+msgstr "Umbenennen"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename palette to:"
+msgstr "Palette umbenennen in:"
+
+#: ../../WINGs/wcolorpanel.c:3245 ../../WINGs/wfilepanel.c:259
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+msgid "Cancel"
+msgstr "Abbrechen"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3261 ../../WINGs/wfilepanel.c:763
+msgid "Warning"
+msgstr "Warnung"
+
+#: ../../WINGs/wcolorpanel.c:3262
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Palette existiert bereits!\n"
+"\n"
+"Überschreiben?"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "No"
+msgstr "Nein"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "Yes"
+msgstr "Ja"
+
+#: ../../WINGs/wcolorpanel.c:3294
+#, c-format
+msgid "Couldn't rename palette %s to %s\n"
+msgstr "Palette %s konnte nicht nach %s umbenannt werden\n"
+
+#: ../../WINGs/wcolorpanel.c:3320
+msgid "This will permanently remove the palette "
+msgstr "Hiermit wird die Palette unwiderruflich gelöscht "
+
+#: ../../WINGs/wcolorpanel.c:3323
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+".\n"
+"\n"
+"Sind Sie sicher, dass Sie die Palette löschen wollen?"
+
+#: ../../WINGs/wcolorpanel.c:3348
+#, c-format
+msgid "Couldn't remove palette %s\n"
+msgstr "Palette %s konnte nicht gelöscht werden\n"
+
+#: ../../WINGs/wcolorpanel.c:3647
+#, c-format
+msgid "Could not open %s"
+msgstr "%s konnte nicht geöffnet werden"
+
+#: ../../WINGs/wcolorpanel.c:3654
+#, c-format
+msgid "Could not create %s"
+msgstr "%s konnte nicht erzeugt werden"
+
+#: ../../WINGs/wcolorpanel.c:3665
+#, c-format
+msgid "Write error on file %s"
+msgstr "Schreibfehler bei Datei %s"
+
+#: ../../WINGs/wcolorpanel.c:3710
+msgid "Color Panel: Color unspecified"
+msgstr "Farb-Panel: Farbe nicht spezifiziert"
+
+#: ../../WINGs/wfilepanel.c:235
+msgid "Name:"
+msgstr "Name:"
+
+#: ../../WINGs/wfilepanel.c:332 ../../WINGs/wfilepanel.c:396
+msgid "Open"
+msgstr "Öffnen"
+
+#: ../../WINGs/wfilepanel.c:350 ../../WINGs/wfilepanel.c:402
+msgid "Save"
+msgstr "Speichern"
+
+#: ../../WINGs/wfilepanel.c:565
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: Verzeichnis %s konnte nicht geöffnet werden\n"
+
+#: ../../WINGs/wfilepanel.c:583
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: Dateistatus von %s unbestimmbar\n"
+
+#: ../../WINGs/wfilepanel.c:650 ../../WINGs/wfilepanel.c:973
+#: ../../WINGs/wfontpanel.c:590
+msgid "Error"
+msgstr "Fehler"
+
+#: ../../WINGs/wfilepanel.c:661
+msgid "Create Directory"
+msgstr "Verzeichnis anlegen"
+
+#: ../../WINGs/wfilepanel.c:662
+msgid "Enter directory name"
+msgstr "Verzeichnisname eingeben"
+
+#: ../../WINGs/wfilepanel.c:698 ../../WINGs/wfilepanel.c:737
+#: ../../WINGs/wfilepanel.c:768 ../../WINGs/wfilepanel.c:796
+msgid "Permission denied."
+msgstr "Zugriff verweigert."
+
+#: ../../WINGs/wfilepanel.c:701
+#, c-format
+msgid "'%s' already exists."
+msgstr "'%s' existiert bereits."
+
+#: ../../WINGs/wfilepanel.c:704
+msgid "Path does not exist."
+msgstr "Pfad existiert nicht."
+
+#: ../../WINGs/wfilepanel.c:734 ../../WINGs/wfilepanel.c:793
+#, c-format
+msgid "'%s' does not exist."
+msgstr "'%s' existiert nicht."
+
+#: ../../WINGs/wfilepanel.c:741 ../../WINGs/wfilepanel.c:800
+msgid "Insufficient memory available."
+msgstr "Nicht genügend Speicher verfügbar."
+
+#: ../../WINGs/wfilepanel.c:745 ../../WINGs/wfilepanel.c:804
+#, c-format
+msgid "'%s' is on a read-only filesystem."
+msgstr "'%s' liegt auf einem nur lesbaren Dateisystem."
+
+#: ../../WINGs/wfilepanel.c:748 ../../WINGs/wfilepanel.c:780
+#: ../../WINGs/wfilepanel.c:807
+#, c-format
+msgid "Can not delete '%s'."
+msgstr "Kann %s nicht löschen."
+
+#: ../../WINGs/wfilepanel.c:755
+#, c-format
+msgid "Delete directory %s ?"
+msgstr "Verzeichnis %s löschen?"
+
+#: ../../WINGs/wfilepanel.c:759
+#, c-format
+msgid "Delete file %s ?"
+msgstr "Datei %s löschen?"
+
+#: ../../WINGs/wfilepanel.c:771
+#, c-format
+msgid "Directory '%s' does not exist."
+msgstr "Verzeichnis '%s' existiert nicht."
+
+#: ../../WINGs/wfilepanel.c:774
+#, c-format
+msgid "Directory '%s' is not empty."
+msgstr "Verzeichnis '%s' ist nicht leer."
+
+#: ../../WINGs/wfilepanel.c:777
+#, c-format
+msgid "Directory '%s' is busy."
+msgstr "Verzeichnis '%s' wird benutz."
+
+#: ../../WINGs/wfilepanel.c:790
+#, c-format
+msgid "'%s' is a directory."
+msgstr "'%s' ist ein Verzeichnis."
+
+#: ../../WINGs/wfilepanel.c:832
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Fehler beim Lesen von '%s'."
+
+#: ../../WINGs/wfilepanel.c:836
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "'%s' ist kein Verzeichnis."
+
+#: ../../WINGs/wfilepanel.c:973
+msgid "File does not exist."
+msgstr "Datei existiert nicht."
+
+#: ../../WINGs/wfont.c:40
+#, c-format
+msgid "invalid font: %s. Trying '%s'"
+msgstr "Ungültige Schriftart: %s. Wird ersetzt durch %s."
+
+#: ../../WINGs/wfont.c:257 ../../WINGs/wfont.c:277
+#, c-format
+msgid "could not load font: %s."
+msgstr "Schriftart konnte nicht geladen werden: %s"
+
+#. WMSetWidgetBackgroundColor(panel->win, WMWhiteColor(scr));
+#: ../../WINGs/wfontpanel.c:203
+msgid "Font Panel"
+msgstr "Schrift-Panel"
+
+#: ../../WINGs/wfontpanel.c:239
+msgid "The quick brown fox jumps over the lazy dog"
+msgstr ""
+
+#: ../../WINGs/wfontpanel.c:245
+msgid "Family"
+msgstr "Familie"
+
+#: ../../WINGs/wfontpanel.c:256
+msgid "Typeface"
+msgstr "Schriftart"
+
+#: ../../WINGs/wfontpanel.c:267
+msgid "Size"
+msgstr "Größe"
+
+#: ../../WINGs/wfontpanel.c:286
+msgid "Set"
+msgstr "Setzen"
+
+#: ../../WINGs/wfontpanel.c:292
+msgid "Revert"
+msgstr "Zurücksetzen"
+
+#: ../../WINGs/wfontpanel.c:591
+msgid "Could not init font config library\n"
+msgstr "\"font-config\"-Bibliothek konnte nicht initialisiert werden\n"
+
+#: ../../WINGs/widgets.c:419
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: Widget-Bilderdatei konnte nicht geladen werden: %s"
+
+#: ../../WINGs/widgets.c:767
+msgid ""
+"could not load any fonts. Make sure your font installation and locale "
+"settings are correct."
+msgstr ""
+"Keine Schrifen konnten geladen werden. Überprüfen Sie, ob Ihre Schrifteninstallation und -"
+"Lokalisierungseinstellungen korrekt sind."
+
+#: ../../WINGs/wruler.c:192
+msgid "0   inches"
+msgstr "0   Inch"
+

bazel/WINGs/po/fr.po

@@ -0,0 +1,739 @@
+# KTranslator Generated File
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR Free Software Foundation, Inc.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: WINGs 0.80.0\n"
+"POT-Creation-Date: 2003-05-02 15:39+0200\n"
+"PO-Revision-Date: 2002-01-09 21:20+0100\n"
+"Last-Translator: Emmanuel Benoit <tseeker@neptune.fr>\n"
+"Language-Team: Français <fr@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: unknown\n"
+
+#: ../../WINGs/connection.c:467 ../../WINGs/connection.c:532
+#: ../../WINGs/connection.c:575
+msgid "Bad address-service-protocol combination"
+msgstr "Mauvaise combinaison adresse-service-protocole"
+
+#: ../../WINGs/error.c:54
+#, c-format
+msgid "Unknown error %d"
+msgstr "Erreur inconnue %d"
+
+#: ../../WINGs/error.c:59
+#, c-format
+msgid "Error %d"
+msgstr "Erreur %d"
+
+#: ../../WINGs/error.c:110
+msgid "warning: "
+msgstr "avertissement : "
+
+#: ../../WINGs/error.c:137
+msgid "fatal: "
+msgstr "erreur fatale : "
+
+#: ../../WINGs/error.c:163 ../../WINGs/error.c:192
+msgid "error: "
+msgstr "erreur : "
+
+#: ../../WINGs/findfile.c:48
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "Impossible de lire le mot de passe de l'UID %i"
+
+#: ../../WINGs/findfile.c:66
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "Impossible de lire le mot de passe de l'utilisateur %s"
+
+#: ../../WINGs/host.c:114
+msgid "Cannot get current host name"
+msgstr "Impossible de déterminer le nom de la machine"
+
+# TODO pas de traduction correcte possible, cf source.
+#: ../../WINGs/proplist.c:91
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "Faute de syntaxe dans %s %s, ligne %i : %s"
+
+#: ../../WINGs/proplist.c:150
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr ""
+"Seuls les types string ou data sont supportés pour une clé de dictionnaire "
+"Proplist"
+
+#: ../../WINGs/proplist.c:184 ../../WINGs/proplist.c:236
+#: ../../WINGs/proplist.c:394 ../../WINGs/proplist.c:474
+#: ../../WINGs/proplist.c:1075 ../../WINGs/proplist.c:1127
+#: ../../WINGs/proplist.c:1293 ../../WINGs/proplist.c:1372
+#: ../../WINGs/proplist.c:1493 ../../WINGs/proplist.c:1540
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr "Une fonction Proplist a été utilisée sur des objets non-WMPropList"
+
+#: ../../WINGs/proplist.c:630
+msgid "unterminated PropList string"
+msgstr "chaîne PropList sans fin"
+
+#: ../../WINGs/proplist.c:670
+msgid "unterminated PropList data"
+msgstr "données PropList sans fin"
+
+#: ../../WINGs/proplist.c:678
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr "données PropList sans fin (il manque un chiffre hexadécimal)"
+
+#: ../../WINGs/proplist.c:690 ../../WINGs/proplist.c:695
+msgid "non hexdigit character in PropList data"
+msgstr "caractère non-hexadécimal dans les données PropList"
+
+#: ../../WINGs/proplist.c:729
+msgid "unterminated PropList array"
+msgstr "tableau PropList sans fin"
+
+#: ../../WINGs/proplist.c:737
+msgid "missing or unterminated PropList array"
+msgstr "tableau PropList manquant ou sans fin"
+
+#: ../../WINGs/proplist.c:747
+msgid "could not get PropList array element"
+msgstr "impossible de lire l'élément du tableau PropList"
+
+#: ../../WINGs/proplist.c:776
+msgid "unterminated PropList dictionary"
+msgstr "dictionnaire PropList sans fin"
+
+#: ../../WINGs/proplist.c:793
+msgid "missing PropList dictionary key"
+msgstr "clef du dictionnaire PropList manquante"
+
+#: ../../WINGs/proplist.c:795
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr "clef du dictionnaire PropList manquante ou dictionnaire sans fin"
+
+#: ../../WINGs/proplist.c:803
+msgid "error parsing PropList dictionary key"
+msgstr "erreur lors de l'analyse de la clef de dictionnaire PropList"
+
+#: ../../WINGs/proplist.c:811
+msgid "missing = in PropList dictionary entry"
+msgstr "signe '=' manquant dans l'entrée du dictionnaire PropList"
+
+#: ../../WINGs/proplist.c:819
+msgid "error parsing PropList dictionary entry value"
+msgstr ""
+"erreur lors de l'analyse de la valeur de l'entrée du dictionnaire PropList"
+
+#: ../../WINGs/proplist.c:827
+msgid "missing ; in PropList dictionary entry"
+msgstr "signe ';' manquant dans l'entrée du dictionnaire PropList"
+
+#: ../../WINGs/proplist.c:888
+msgid ""
+"was expecting a string, data, array or dictionary. If it's a string, try "
+"enclosing it with \"."
+msgstr ""
+"une chaine, des données, un tableau ou un dictionnaire étaient attendus. "
+"S'il s'agit d'une chaîne, essayez de la délimiter grâce à '\"'."
+
+#: ../../WINGs/proplist.c:892
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr ""
+"Les commentaires ne sont pas autorisés dans les fichiers appartenant au "
+"domaine de Window Maker."
+
+#: ../../WINGs/proplist.c:1563 ../../WINGs/proplist.c:1628
+msgid "extra data after end of property list"
+msgstr "données excédentaires après la fin de la liste de propriétés"
+
+#: ../../WINGs/proplist.c:1606
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "impossible de déterminer la taille du fichier '%s'"
+
+#: ../../WINGs/proplist.c:1618
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "erreur pendant la lecture du fichier '%s'"
+
+#: ../../WINGs/proplist.c:1669
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "mkstemp (%s) a échoué"
+
+#: ../../WINGs/proplist.c:1680
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "mktemp (%s) a échoué"
+
+#: ../../WINGs/proplist.c:1691
+#, c-format
+msgid "open (%s) failed"
+msgstr "open (%s) a échoué"
+
+#: ../../WINGs/proplist.c:1698
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "erreur pendant l'écriture dans le fichier '%s'"
+
+#: ../../WINGs/proplist.c:1706
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "erreur lors de la fermeture du fichier '%s'"
+
+#: ../../WINGs/proplist.c:1715
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "impossible de renommer '%s' en '%s'"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:188 ../../WINGs/userdefaults.c:204
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr ""
+"impossible de lire le domaine depuis le fichier '%s' pendant la "
+"synchronisation"
+
+#: ../../WINGs/wcolor.c:224 ../../WINGs/wcolor.c:236 ../../WINGs/wcolor.c:275
+#: ../../WINGs/wcolor.c:316
+#, c-format
+msgid "could not allocate %s color"
+msgstr "impossible d'allouer la couleur %s"
+
+#: ../../WINGs/wcolor.c:224
+msgid "white"
+msgstr "blanc"
+
+#: ../../WINGs/wcolor.c:236
+msgid "black"
+msgstr "noir"
+
+#: ../../WINGs/wcolor.c:275
+msgid "gray"
+msgstr "gris"
+
+#: ../../WINGs/wcolor.c:316
+msgid "dark gray"
+msgstr "gris sombre"
+
+#: ../../WINGs/wcolorpanel.c:420
+msgid "Colors"
+msgstr "Couleurs"
+
+#: ../../WINGs/wcolorpanel.c:610 ../../WINGs/wcolorpanel.c:2829
+msgid "Brightness"
+msgstr "Luminosité"
+
+#: ../../WINGs/wcolorpanel.c:612 ../../WINGs/wcolorpanel.c:688
+#: ../../WINGs/wcolorpanel.c:721 ../../WINGs/wcolorpanel.c:755
+#: ../../WINGs/wcolorpanel.c:815 ../../WINGs/wcolorpanel.c:849
+#: ../../WINGs/wcolorpanel.c:883 ../../WINGs/wcolorpanel.c:918
+#: ../../WINGs/wcolorpanel.c:2169 ../../WINGs/wcolorpanel.c:2831
+#: ../../WINGs/wcolorpanel.c:2867 ../../WINGs/wcolorpanel.c:2903
+#: ../../WINGs/wcolorpanel.c:3745
+msgid "Color Panel: Could not allocate memory"
+msgstr "Panneau de Sélection des Couleur: impossible d'allouer la mémoire"
+
+#: ../../WINGs/wcolorpanel.c:685 ../../WINGs/wcolorpanel.c:686
+msgid "Red"
+msgstr "Rouge"
+
+#: ../../WINGs/wcolorpanel.c:718 ../../WINGs/wcolorpanel.c:719
+msgid "Green"
+msgstr "Vert"
+
+#: ../../WINGs/wcolorpanel.c:752 ../../WINGs/wcolorpanel.c:753
+msgid "Blue"
+msgstr "Bleu"
+
+#: ../../WINGs/wcolorpanel.c:812 ../../WINGs/wcolorpanel.c:813
+msgid "Cyan"
+msgstr "Cyan"
+
+#: ../../WINGs/wcolorpanel.c:846 ../../WINGs/wcolorpanel.c:847
+msgid "Magenta"
+msgstr "Magenta"
+
+#: ../../WINGs/wcolorpanel.c:880 ../../WINGs/wcolorpanel.c:881
+msgid "Yellow"
+msgstr "Jaune"
+
+#: ../../WINGs/wcolorpanel.c:915 ../../WINGs/wcolorpanel.c:916
+msgid "Black"
+msgstr "Noir"
+
+#: ../../WINGs/wcolorpanel.c:996
+msgid "Spectrum"
+msgstr "Spectre"
+
+#: ../../WINGs/wcolorpanel.c:1026
+msgid "Palette"
+msgstr "Palette"
+
+#: ../../WINGs/wcolorpanel.c:1032
+msgid "New from File..."
+msgstr "Nouveau d'après le fichier..."
+
+#: ../../WINGs/wcolorpanel.c:1033 ../../WINGs/wcolorpanel.c:1081
+#: ../../WINGs/wcolorpanel.c:1098
+msgid "Rename..."
+msgstr "Renommer..."
+
+#: ../../WINGs/wcolorpanel.c:1034 ../../WINGs/wcolorpanel.c:1082
+#: ../../WINGs/wcolorpanel.c:1099 ../../WINGs/wcolorpanel.c:3326
+msgid "Remove"
+msgstr "Supprimer"
+
+#: ../../WINGs/wcolorpanel.c:1035
+msgid "Copy"
+msgstr "Copier"
+
+#: ../../WINGs/wcolorpanel.c:1036
+msgid "New from Clipboard"
+msgstr "Nouveau d'après le presse-papier"
+
+#: ../../WINGs/wcolorpanel.c:1057
+msgid "X11-Colors"
+msgstr "Couleurs X11"
+
+#: ../../WINGs/wcolorpanel.c:1074
+msgid "Color"
+msgstr "Couleur"
+
+#: ../../WINGs/wcolorpanel.c:1080
+msgid "Add..."
+msgstr "Ajouter..."
+
+#: ../../WINGs/wcolorpanel.c:1090
+msgid "List"
+msgstr "Liste"
+
+#: ../../WINGs/wcolorpanel.c:1097
+msgid "New..."
+msgstr "Nouveau..."
+
+#: ../../WINGs/wcolorpanel.c:1236
+#, c-format
+msgid ""
+"Color Panel: Could not create directory %s needed to store configurations"
+msgstr ""
+"Panneau de sélection des couleurs : impossible de créer le répertoire %s "
+"requis pour enregistrer les configurations."
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1242 ../../WINGs/wcolorpanel.c:3212
+#: ../../WINGs/wcolorpanel.c:3216
+msgid "File Error"
+msgstr "Erreur de fichier"
+
+#: ../../WINGs/wcolorpanel.c:1243
+msgid "Could not create ColorPanel configuration directory"
+msgstr ""
+"Impossible de créer le répertoire pour la configuration du panneau de "
+"sélection des couleurs."
+
+#: ../../WINGs/wcolorpanel.c:1244 ../../WINGs/wcolorpanel.c:3213
+#: ../../WINGs/wcolorpanel.c:3218 ../../WINGs/wcolorpanel.c:3245
+#: ../../WINGs/wfilepanel.c:250 ../../WINGs/wfilepanel.c:650
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+#: ../../WINGs/wfilepanel.c:974 ../../WINGs/wfontpanel.c:751
+msgid "OK"
+msgstr "OK"
+
+#: ../../WINGs/wcolorpanel.c:1250 ../../WINGs/wcolorpanel.c:1286
+#: ../../WINGs/wcolorpanel.c:1304
+msgid "Color Panel: Could not find file"
+msgstr "Panneau de sélection des couleurs : Impossible de trouver le fichier."
+
+#: ../../WINGs/wcolorpanel.c:1491 ../../WINGs/wcolorpanel.c:1556
+#: ../../WINGs/wcolorpanel.c:1620
+msgid "Color Panel: X failed request"
+msgstr "Panneau de sélection des couleurs : échec d'une requête X"
+
+#: ../../WINGs/wcolorpanel.c:2865
+msgid "Saturation"
+msgstr "Saturation"
+
+#: ../../WINGs/wcolorpanel.c:2901
+msgid "Hue"
+msgstr "Teinte"
+
+#: ../../WINGs/wcolorpanel.c:3151
+msgid "Open Palette"
+msgstr "Ouvrir une palette"
+
+#: ../../WINGs/wcolorpanel.c:3213
+msgid "Invalid file format !"
+msgstr "Format de fichier invalide !"
+
+#: ../../WINGs/wcolorpanel.c:3215
+#, c-format
+msgid "can't remove file %s"
+msgstr "Impossible de supprimer le fichier %s."
+
+#: ../../WINGs/wcolorpanel.c:3217
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Impossible de supprimer le fichier du répertoire de configuration !"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename"
+msgstr "Renommer"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename palette to:"
+msgstr "Renommer la palette en :"
+
+#: ../../WINGs/wcolorpanel.c:3245 ../../WINGs/wfilepanel.c:259
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+msgid "Cancel"
+msgstr "Annuler"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3261 ../../WINGs/wfilepanel.c:763
+msgid "Warning"
+msgstr "Avertissement"
+
+#: ../../WINGs/wcolorpanel.c:3262
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"La palette existe déjà !\n"
+"\n"
+"Écraser ?"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "No"
+msgstr "Non"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "Yes"
+msgstr "Oui"
+
+#: ../../WINGs/wcolorpanel.c:3294
+#, c-format
+msgid "Couldn't rename palette %s to %s\n"
+msgstr "Impossible de renommer la palette %s en %s.\n"
+
+#: ../../WINGs/wcolorpanel.c:3320
+msgid "This will permanently remove the palette "
+msgstr "Ceci détruira définitivement la palette "
+
+#: ../../WINGs/wcolorpanel.c:3323
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+".\n"
+"\n"
+"Êtes-vous sûr de vouloir supprimer cette palette ?"
+
+#: ../../WINGs/wcolorpanel.c:3348
+#, c-format
+msgid "Couldn't remove palette %s\n"
+msgstr "Impossible de détruire la palette %s.\n"
+
+#: ../../WINGs/wcolorpanel.c:3647
+#, c-format
+msgid "Could not open %s"
+msgstr "Impossible d'ouvrir %s."
+
+#: ../../WINGs/wcolorpanel.c:3654
+#, c-format
+msgid "Could not create %s"
+msgstr "Impossible de créer %s."
+
+#: ../../WINGs/wcolorpanel.c:3665
+#, c-format
+msgid "Write error on file %s"
+msgstr "Erreur d'écriture dans le fichier %s."
+
+#: ../../WINGs/wcolorpanel.c:3710
+msgid "Color Panel: Color unspecified"
+msgstr "Panneau de sélection des couleurs: couleur non spécifiée."
+
+#: ../../WINGs/wfilepanel.c:235
+msgid "Name:"
+msgstr "Nom :"
+
+#: ../../WINGs/wfilepanel.c:332 ../../WINGs/wfilepanel.c:396
+msgid "Open"
+msgstr "Ouvrir"
+
+#: ../../WINGs/wfilepanel.c:350 ../../WINGs/wfilepanel.c:402
+msgid "Save"
+msgstr "Enregistrer"
+
+#: ../../WINGs/wfilepanel.c:565
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs : Impossible d'ouvrir le répertoire %s.\n"
+
+#: ../../WINGs/wfilepanel.c:583
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs : impossible de lire l'état du fichier %s.\n"
+
+#: ../../WINGs/wfilepanel.c:650 ../../WINGs/wfilepanel.c:973
+#: ../../WINGs/wfontpanel.c:750
+msgid "Error"
+msgstr "Erreur"
+
+#: ../../WINGs/wfilepanel.c:661
+msgid "Create Directory"
+msgstr "Créer un répertoire"
+
+#: ../../WINGs/wfilepanel.c:662
+msgid "Enter directory name"
+msgstr "Saisissez le nom du répertoire"
+
+#: ../../WINGs/wfilepanel.c:698 ../../WINGs/wfilepanel.c:737
+#: ../../WINGs/wfilepanel.c:768 ../../WINGs/wfilepanel.c:796
+msgid "Permission denied."
+msgstr "Permission refusée."
+
+#: ../../WINGs/wfilepanel.c:701
+#, c-format
+msgid "'%s' already exists."
+msgstr "'%s' existe déjà."
+
+#: ../../WINGs/wfilepanel.c:704
+msgid "Path does not exist."
+msgstr "Le chemin n'existe pas."
+
+#: ../../WINGs/wfilepanel.c:734 ../../WINGs/wfilepanel.c:793
+#, c-format
+msgid "'%s' does not exist."
+msgstr "'%s' n'existe pas."
+
+#: ../../WINGs/wfilepanel.c:741 ../../WINGs/wfilepanel.c:800
+msgid "Insufficient memory available."
+msgstr "Mémoire disponible insuffisante."
+
+#: ../../WINGs/wfilepanel.c:745 ../../WINGs/wfilepanel.c:804
+#, c-format
+msgid "'%s' is on a read-only filesystem."
+msgstr "'%s' est sur un système de fichiers en lecture seule."
+
+#: ../../WINGs/wfilepanel.c:748 ../../WINGs/wfilepanel.c:780
+#: ../../WINGs/wfilepanel.c:807
+#, c-format
+msgid "Can not delete '%s'."
+msgstr "Impossible de supprimer '%s'."
+
+#: ../../WINGs/wfilepanel.c:755
+#, c-format
+msgid "Delete directory %s ?"
+msgstr "Supprimer le répertoire %s ?"
+
+#: ../../WINGs/wfilepanel.c:759
+#, c-format
+msgid "Delete file %s ?"
+msgstr "Supprimer le fichier %s ?"
+
+#: ../../WINGs/wfilepanel.c:771
+#, c-format
+msgid "Directory '%s' does not exist."
+msgstr "Le répertoire '%s' n'existe pas."
+
+#: ../../WINGs/wfilepanel.c:774
+#, c-format
+msgid "Directory '%s' is not empty."
+msgstr "Le répertoire '%s' n'est pas vide."
+
+#: ../../WINGs/wfilepanel.c:777
+#, c-format
+msgid "Directory '%s' is busy."
+msgstr "Le répertoire '%s' est occupé."
+
+#: ../../WINGs/wfilepanel.c:790
+#, c-format
+msgid "'%s' is a directory."
+msgstr "'%s' est un répertoire."
+
+#: ../../WINGs/wfilepanel.c:832
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Une erreur s'est produite pendant le parcours de '%s'."
+
+#: ../../WINGs/wfilepanel.c:836
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "'%s' n'est pas un répertoire."
+
+#: ../../WINGs/wfilepanel.c:973
+msgid "File does not exist."
+msgstr "Le fichier n'existe pas."
+
+#: ../../WINGs/wfont.c:133 ../../WINGs/wfont.c:143
+#, c-format
+msgid "Invalid size specification '%s' in %s. Using default %d\n"
+msgstr ""
+"Taille invalide dans %2$s : '%1$s'. Utilisation de la valeur par défaut %3"
+"$d\n"
+
+#: ../../WINGs/wfont.c:187
+#, c-format
+msgid "the following character sets are missing in %s:"
+msgstr "Les jeux de caractères suivants manquent dans %s :"
+
+#: ../../WINGs/wfont.c:193
+#, c-format
+msgid ""
+"the string \"%s\" will be used in place of any characters from those sets."
+msgstr ""
+"La chaîne « %s » sera utilisée à la place de tous les caractères de ces jeux."
+
+#. is arial a good fallback for multibyte?
+#: ../../WINGs/wfont.c:599 ../../WINGs/wfont.c:614
+#, c-format
+msgid "could not load font %s. Trying arial."
+msgstr ""
+"Impossible de charger la police de caractères %s, essai de la police "
+"« arial »."
+
+#: ../../WINGs/wfont.c:606
+msgid "could not load antialiased font set. Reverting to standard font sets."
+msgstr ""
+"Impossible de charger les polices lissées, utilisation des polices normales."
+
+#: ../../WINGs/wfont.c:609
+#, c-format
+msgid "could not load FontSet %s. Trying fixed."
+msgstr ""
+"Impossible de charger la famille de polices %s, essai de la famille "
+"« fixed »."
+
+#: ../../WINGs/wfont.c:621
+msgid "could not load antialiased fonts. Reverting to normal fonts."
+msgstr ""
+"Impossible de charger les polices lissées, utilisation des polices normales."
+
+#: ../../WINGs/wfont.c:624 ../../WINGs/wfont.c:635
+#, c-format
+msgid "could not load font %s. Trying fixed."
+msgstr ""
+"Impossible de charger la police de caractères %s, essai de la police "
+"« fixed »."
+
+#: ../../WINGs/wfont.c:629
+#, c-format
+msgid "could not load font set %s. Trying fixed."
+msgstr ""
+"Impossible de charger la famille de polices %s, essai de la famille "
+"« fixed »."
+
+#: ../../WINGs/wfont.c:639
+msgid "could not load fixed font!"
+msgstr "Impossible de charger la police de caractères « fixed » !"
+
+#: ../../WINGs/wfont.c:704 ../../WINGs/wfont.c:765 ../../WINGs/wfont.c:836
+#, c-format
+msgid ""
+"Conversion to widechar failed (possible invalid multibyte sequence): '%s':"
+"(pos %d)\n"
+msgstr ""
+"Échec de la conversion en widechar (probablement une séquence d'octets "
+"erronée) : « %s » (pos %d)\n"
+
+#: ../../WINGs/wfont.c:887
+#, c-format
+msgid "font description %s is too large."
+msgstr "La description de la police de caractères %s est trop volumineuse."
+
+#. // remove warning later. or maybe not
+#: ../../WINGs/wfont.c:935
+#, c-format
+msgid "Invalid font specification: '%s'\n"
+msgstr "Déclaration de police invalide : « %s »\n"
+
+#: ../../WINGs/wfontpanel.c:235
+msgid "Test!!!"
+msgstr "Test !"
+
+#: ../../WINGs/wfontpanel.c:241
+msgid "Family"
+msgstr "Famille"
+
+#: ../../WINGs/wfontpanel.c:252
+msgid "Typeface"
+msgstr "Caractère"
+
+#: ../../WINGs/wfontpanel.c:263
+msgid "Size"
+msgstr "Taille"
+
+#: ../../WINGs/wfontpanel.c:282
+msgid "Set"
+msgstr "Famille"
+
+#: ../../WINGs/wfontpanel.c:288
+msgid "Revert"
+msgstr "Revenir"
+
+#: ../../WINGs/wfontpanel.c:751
+msgid "Could not retrieve font list"
+msgstr "Impossible de lire la liste des polices de caractères."
+
+#: ../../WINGs/wfontpanel.c:765
+#, c-format
+msgid "font name %s is longer than 256, which is invalid."
+msgstr ""
+"Le nom de police %s a plus de 256 caractères et est par conséquent invalide."
+
+#: ../../WINGs/wfontpanel.c:913
+msgid "Roman"
+msgstr "Roman"
+
+#: ../../WINGs/wfontpanel.c:916
+msgid "Italic"
+msgstr "Italique"
+
+#: ../../WINGs/wfontpanel.c:918
+msgid "Oblique"
+msgstr "Penché"
+
+#: ../../WINGs/wfontpanel.c:920
+msgid "Rev Italic"
+msgstr "Italique inverse"
+
+#: ../../WINGs/wfontpanel.c:922
+msgid "Rev Oblique"
+msgstr "Penché inverse"
+
+#: ../../WINGs/wfontpanel.c:928
+msgid "Normal"
+msgstr "Normal"
+
+#: ../../WINGs/widgets.c:419
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs : impossible de charger le fichier d'images de widget '%s'."
+
+#: ../../WINGs/widgets.c:770
+msgid ""
+"Text antialiasing is enabled in the configuration but the X server doesn't "
+"have the required capabilities (missing RENDER extension). Disabling text "
+"antialiasing."
+msgstr ""
+"Le lissage du texte est activé dans la configuration mais le serveur X ne "
+"dispose pas de l'extension adéquate (extension RENDER). Desactivation du "
+"lissage."
+
+#: ../../WINGs/widgets.c:787
+msgid ""
+"could not load any fonts. Make sure your font installation and locale "
+"settings are correct."
+msgstr ""
+"Aucune police n'a pu être chargée. Veuillez vérifier que vos polices sont "
+"correctement installées et que votre langue est bien configurée."
+
+#: ../../WINGs/wruler.c:192
+msgid "0   inches"
+msgstr "0   pouces"

bazel/WINGs/po/fy.po

@@ -0,0 +1,835 @@
+# Translation into Western Frisian for Window Maker
+# Copyright (C) 2015-2019 Window Maker Developers Team
+# This file is distributed under the same license as the windowmaker package.
+# Original by Alwin <translations@ziggo.nl>, 2015.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: wmaker-0.95.7+\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2016-01-21 16:19+0100\n"
+"PO-Revision-Date: 2016-01-21 00:00+0000\n"
+"Last-Translator: Alwin <translations@ziggo.nl>\n"
+"Language-Team: Western Frisian\n"
+"Language: fy\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../../WINGs/error.c:106
+msgid "fatal: "
+msgstr "ûnwerstelber: "
+
+#: ../../WINGs/error.c:112
+msgid "error: "
+msgstr "flater: "
+
+#: ../../WINGs/error.c:118
+msgid "warning: "
+msgstr "warskôging: "
+
+#: ../../WINGs/findfile.c:63
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "koe accountgegevens foar UID %i net krije"
+
+#: ../../WINGs/findfile.c:93
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "koe accountgegevens foar brûker %s net krije"
+
+#: ../../WINGs/findfile.c:212
+#, c-format
+msgid "could not expand %s"
+msgstr "koe %s net útwurkje"
+
+#: ../../WINGs/findfile.c:441
+#, c-format
+msgid "Could not open input file \"%s\": %s"
+msgstr "Koe ynfierbestân \"%s\" net iepenje: %s"
+
+#: ../../WINGs/findfile.c:457
+#, c-format
+msgid "Could not create target file \"%s\": %s"
+msgstr "Koe doelbestân \"%s\" net oanmeitsje: %s"
+
+#: ../../WINGs/findfile.c:465
+msgid "could not allocate memory for the copy buffer"
+msgstr "koe ûnthâld foar de kopybuffer net tawize"
+
+#: ../../WINGs/findfile.c:482
+#, c-format
+msgid "could not read from file \"%s\": %s"
+msgstr "koe bestân \"%s\" net ynlêze: %s"
+
+#: ../../WINGs/findfile.c:497
+#, c-format
+msgid "could not write data to file \"%s\": %s"
+msgstr "koe gjin data skriuwe nei bestân \"%s\": %s"
+
+#: ../../WINGs/findfile.c:509
+#, c-format
+msgid "could not set permission 0%03o on file \"%s\": %s"
+msgstr "koe tastimming 0%03o net ynstelle op bestân \"%s\": %s"
+
+#: ../../WINGs/findfile.c:513
+#, c-format
+msgid "could not close the file \"%s\": %s"
+msgstr "koe bestân \"%s\" net ôfslute: %s"
+
+#: ../../WINGs/menuparser.c:110
+#, c-format
+msgid "   included from file \"%s\" at line %d"
+msgstr "   ynfoege út bestân \"%s\" op rigel %d"
+
+#: ../../WINGs/menuparser.c:142
+#, c-format
+msgid "missing #endif to match #%s at line %d"
+msgstr "ûntbrekkende #endif behearrend by #%s op rigel %d"
+
+#: ../../WINGs/menuparser.c:200
+msgid "multiple SHORTCUT definition not valid"
+msgstr "meartallige SHORTCUT-bepalingen net jildich"
+
+#: ../../WINGs/menuparser.c:253
+msgid "premature end of file while expecting a new line after '\\'"
+msgstr "foartidich bestânsein, ferwachte in nije rigel nei '\\'"
+
+#: ../../WINGs/menuparser.c:279
+#, c-format
+msgid "reached end of file while searching '*/' for comment started at line %d"
+msgstr ""
+"bestânsein berikt by sykjen nei '*/' foar kommentaar begûnen op rigel %d"
+
+#: ../../WINGs/menuparser.c:344
+msgid "missing closing double-quote before end-of-line"
+msgstr "ûntbrekkend slutend dûbeld oanhelteken foar rigelein"
+
+#: ../../WINGs/menuparser.c:362
+msgid "missing closing simple-quote before end-of-line"
+msgstr "ûntbrekkend slutend inkeld oanhelteken foar rigelein"
+
+#: ../../WINGs/menuparser.c:380
+msgid "too many nested macro expansions, breaking loop"
+msgstr "te folle neske makro-útwurkingen, syklus ôfbrutsen"
+
+#: ../../WINGs/menuparser.c:439
+#, c-format
+msgid "unknown directive '#%s'"
+msgstr "ûnbekende oanwizing '#%s'"
+
+#: ../../WINGs/menuparser.c:444
+#, c-format
+msgid "extra text after '#' command is ignored: \"%.16s...\""
+msgstr "ekstra tekst nei #-kommando wurdt negearre: \"%.16s...\""
+
+#: ../../WINGs/menuparser.c:459
+msgid "no file name found for #include"
+msgstr "gjin bestânsnamme fûn foar #include"
+
+#: ../../WINGs/menuparser.c:471
+msgid "file name must be enclosed in brackets or double-quotes for #define"
+msgstr ""
+"bestânsnamme moat omsletten wurde mei heakjes of dûbelde oanheltekens foar "
+"#define"
+
+#: ../../WINGs/menuparser.c:485
+#, c-format
+msgid "missing closing '%c' in filename specification"
+msgstr "ûntbrekkende slutende '%c' yn bestânsnammeopjefte"
+
+#: ../../WINGs/menuparser.c:503
+msgid "too many nested #include's"
+msgstr "te folle neske #include's"
+
+#: ../../WINGs/menuparser.c:568
+#, c-format
+msgid "could not find file \"%s\" for #include"
+msgstr "koe bestân \"%s\" net fine foar #include"
+
+#: ../../WINGs/menuparser.c:589
+#, c-format
+msgid "missing macro name argument to #%s"
+msgstr "ûntbrekkend makronamme-argumint by #%s"
+
+#: ../../WINGs/menuparser.c:600
+msgid "too many nested #if sequences"
+msgstr "te folle neske #if-rigen"
+
+#: ../../WINGs/menuparser.c:626 ../../WINGs/menuparser.c:643
+#, c-format
+msgid "found #%s but has no matching #if"
+msgstr "#%s fûn, mar hat gjin bybehearrende #if"
+
+#: ../../WINGs/menuparser_macros.c:166
+msgid "no macro name found for #define"
+msgstr "gjin makronamme fûn foar #define"
+
+#: ../../WINGs/menuparser_macros.c:187
+#, c-format
+msgid "premature end of file while reading arg-list for macro \"%s\""
+msgstr "foartidich bestânsein by ynlêzen arg.-list foar makro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:194
+#, c-format
+msgid "too many parameters for macro \"%s\" definition"
+msgstr "te folle parameters foar bepaling makro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:209
+#, c-format
+msgid ""
+"invalid character '%c' in arg-list for macro \"%s\" while expecting "
+"parameter name"
+msgstr ""
+"ûnjildich letterteken '%c' yn arg.-list foar makro \"%s\", ferwachte "
+"parameternamme"
+
+#: ../../WINGs/menuparser_macros.c:220
+#, c-format
+msgid ""
+"invalid character '%c' in arg-list for macro \"%s\" while expecting ',' or "
+"')'"
+msgstr ""
+"ûnjildich letterteken '%c' yn arg.-list foar makro \"%s\", ferwachte ',' of "
+"')'"
+
+#: ../../WINGs/menuparser_macros.c:253
+#, c-format
+msgid "macro \"%s\" already defined, ignoring redefinition"
+msgstr "makro \"%s\" al definiearre, negearret werdefiniearjen"
+
+#: ../../WINGs/menuparser_macros.c:346
+#, c-format
+msgid "more content than supported for the macro \"%s\""
+msgstr "mear ynhâld as stipe foar makro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:455
+#, c-format
+msgid "expansion for macro \"%s\" too big, line truncated"
+msgstr "útwurking foar makro \"%s\" te grut, rigel ynkoarte"
+
+#: ../../WINGs/menuparser_macros.c:467
+#, c-format
+msgid "macro \"%s\" needs parenthesis for arguments"
+msgstr "makro \"%s\" hat heakjes nedich foar arguminten"
+
+#: ../../WINGs/menuparser_macros.c:498
+msgid "missing closing quote or double-quote before end-of-line"
+msgstr "ûntbrekkend slutend of dûbeld oanhelteken foar rigelein"
+
+#: ../../WINGs/menuparser_macros.c:521
+#, c-format
+msgid "too many arguments for macro \"%s\", expected only %d"
+msgstr "te folle arguminten foar makro \"%s\", ferwachte allinnich %d"
+
+#: ../../WINGs/menuparser_macros.c:530
+#, c-format
+msgid "premature end of line while searching for arguments to macro \"%s\""
+msgstr "foartidich rigelein by sykjen nei arguminten by makro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:536
+#, c-format
+msgid "not enough arguments for macro \"%s\", expected %d but got only %d"
+msgstr ""
+"ûnfoldwaande arguminten foar makro \"%s\", ferwachte %d, mar krige allinnich "
+"%d"
+
+#: ../../WINGs/menuparser_macros.c:541
+#, c-format
+msgid "too much data in parameter list of macro \"%s\", truncated"
+msgstr "te folle data yn parameterlist fan makro \"%s\", ynkoarte"
+
+#: ../../WINGs/menuparser_macros.c:561
+#, c-format
+msgid "size of value for macro '%s' is too big, truncated"
+msgstr "wearde foar makro '%s' is te lang, ynkoarte"
+
+#: ../../WINGs/menuparser_macros.c:642 ../../WINGs/menuparser_macros.c:668
+#, c-format
+msgid "could not determine %s"
+msgstr "koe %s net fêststelle"
+
+#: ../../WINGs/proplist.c:78
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "syntaksflater yn %s %s, rigel %i: %s"
+
+#: ../../WINGs/proplist.c:134
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr ""
+
+#: ../../WINGs/proplist.c:167 ../../WINGs/proplist.c:217
+#: ../../WINGs/proplist.c:382 ../../WINGs/proplist.c:458
+#: ../../WINGs/proplist.c:1048 ../../WINGs/proplist.c:1098
+#: ../../WINGs/proplist.c:1246 ../../WINGs/proplist.c:1314
+#: ../../WINGs/proplist.c:1419 ../../WINGs/proplist.c:1463
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr ""
+
+#: ../../WINGs/proplist.c:635
+msgid "unterminated PropList string"
+msgstr ""
+
+#: ../../WINGs/proplist.c:673
+msgid "unterminated PropList data"
+msgstr ""
+
+#: ../../WINGs/proplist.c:681
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr ""
+
+#: ../../WINGs/proplist.c:693 ../../WINGs/proplist.c:698
+msgid "non hexdigit character in PropList data"
+msgstr ""
+
+#: ../../WINGs/proplist.c:730
+msgid "unterminated PropList array"
+msgstr ""
+
+#: ../../WINGs/proplist.c:738
+msgid "missing or unterminated PropList array"
+msgstr ""
+
+#: ../../WINGs/proplist.c:748
+msgid "could not get PropList array element"
+msgstr ""
+
+#: ../../WINGs/proplist.c:775
+msgid "unterminated PropList dictionary"
+msgstr ""
+
+#: ../../WINGs/proplist.c:792
+msgid "missing PropList dictionary key"
+msgstr ""
+
+#: ../../WINGs/proplist.c:794
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr ""
+
+#: ../../WINGs/proplist.c:802
+msgid "error parsing PropList dictionary key"
+msgstr ""
+
+#: ../../WINGs/proplist.c:810
+msgid "missing = in PropList dictionary entry"
+msgstr ""
+
+#: ../../WINGs/proplist.c:818
+msgid "error parsing PropList dictionary entry value"
+msgstr ""
+
+#: ../../WINGs/proplist.c:826
+msgid "missing ; in PropList dictionary entry"
+msgstr ""
+
+#: ../../WINGs/proplist.c:885
+msgid ""
+"was expecting a string, data, array or dictionary. If it's a string, try "
+"enclosing it with \"."
+msgstr ""
+
+#: ../../WINGs/proplist.c:888
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "Kommentaar is net tastean binnen domeinbestannen fan WindowMaker."
+
+#: ../../WINGs/proplist.c:1483 ../../WINGs/proplist.c:1548
+#: ../../WINGs/proplist.c:1612
+msgid "extra data after end of property list"
+msgstr "ekstra data nei ein fan 'property list'"
+
+#: ../../WINGs/proplist.c:1523
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "koe grutte foar bestân '%s' net krije"
+
+#: ../../WINGs/proplist.c:1531
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "flater by ynlêzen bestân '%s'"
+
+#: ../../WINGs/proplist.c:1578
+#, c-format
+msgid "%s:could not open menu file"
+msgstr "%s:koe menubestân net iepenje"
+
+#: ../../WINGs/proplist.c:1660
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "oanmeitsjen unyk tydlik bestân (%s) mislearre"
+
+#: ../../WINGs/proplist.c:1670
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "oanmeitsjen tydlik bestân (%s) mislearre"
+
+#: ../../WINGs/proplist.c:1677
+#, c-format
+msgid "open (%s) failed"
+msgstr "iepenjen (%s) mislearre"
+
+#: ../../WINGs/proplist.c:1684
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "skriuwen nei bestân: %s mislearre"
+
+#: ../../WINGs/proplist.c:1693
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "ôfsluten stream (%s) mislearre"
+
+#: ../../WINGs/proplist.c:1701
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "omneamen ('%s' nei '%s') mislearre"
+
+#: ../../WINGs/proplist.c:1772
+#, c-format
+msgid "Could not create component %s"
+msgstr "Koe komponint %s net oanmeitsje"
+
+#: ../../WINGs/userdefaults.c:72
+msgid "variable WMAKER_USER_ROOT defined with invalid path, not used"
+msgstr "fariabele WMAKER_USER_ROOT, definiearre mei ûnjildich paad, net brûkt"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:210 ../../WINGs/userdefaults.c:225
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "kin domeinbestân '%s' net ynlêze by syngronisearjen"
+
+#: ../../WINGs/dragcommon.c:60
+#, c-format
+msgid "unknown XDND action %s"
+msgstr "ûnbekende XDND-aksje %s"
+
+#: ../../WINGs/dragcommon.c:142
+#, c-format
+msgid "target %lu for XDND message no longer exists"
+msgstr "doel %lu foar XDND-berjocht bestiet net mear"
+
+#: ../../WINGs/dragcommon.c:220
+#, c-format
+msgid "unsupported version %i for XDND enter message"
+msgstr "net-stipe ferzje %i foar XDND-berjocht by binnen gean"
+
+#: ../../WINGs/dragsource.c:163
+msgid "XDND selection lost during drag operation..."
+msgstr "XDND-seleksje ferlern ûnder fersleephanneling..."
+
+#: ../../WINGs/dragsource.c:758
+msgid "could not get XDND version for target of drop"
+msgstr "koe XDND-ferzje net krije foar doel fan ferslepen"
+
+#: ../../WINGs/dragsource.c:774
+msgid "could not get ownership of XDND selection"
+msgstr "koe eigendom fan XDND-seleksje net krije"
+
+#: ../../WINGs/dragsource.c:1070
+msgid "delay for drag destination response expired"
+msgstr "wachttiid foar antwurd fersleepbestimming ferstrutsen"
+
+#: ../../WINGs/wcolor.c:204 ../../WINGs/wcolor.c:214 ../../WINGs/wcolor.c:250
+#: ../../WINGs/wcolor.c:288
+#, c-format
+msgid "could not allocate %s color"
+msgstr "koe kleur %s net tawize"
+
+#: ../../WINGs/wcolor.c:204
+msgid "white"
+msgstr "wyt"
+
+#: ../../WINGs/wcolor.c:214
+msgid "black"
+msgstr "swart"
+
+#: ../../WINGs/wcolor.c:250
+msgid "gray"
+msgstr "griis"
+
+#: ../../WINGs/wcolor.c:288
+msgid "dark gray"
+msgstr "donkergriis"
+
+#: ../../WINGs/wcolorpanel.c:393
+msgid "Colors"
+msgstr "Kleuren"
+
+#: ../../WINGs/wcolorpanel.c:568 ../../WINGs/wcolorpanel.c:2720
+msgid "Brightness"
+msgstr "Helderens"
+
+#: ../../WINGs/wcolorpanel.c:570 ../../WINGs/wcolorpanel.c:644
+#: ../../WINGs/wcolorpanel.c:675 ../../WINGs/wcolorpanel.c:706
+#: ../../WINGs/wcolorpanel.c:781 ../../WINGs/wcolorpanel.c:812
+#: ../../WINGs/wcolorpanel.c:844 ../../WINGs/wcolorpanel.c:877
+#: ../../WINGs/wcolorpanel.c:2016 ../../WINGs/wcolorpanel.c:2722
+#: ../../WINGs/wcolorpanel.c:2756 ../../WINGs/wcolorpanel.c:2790
+msgid "Color Panel: Could not allocate memory"
+msgstr "Kleurepaniel: Koe gjin ûnthâld tawize"
+
+#: ../../WINGs/wcolorpanel.c:642
+msgid "Red"
+msgstr "Read"
+
+#: ../../WINGs/wcolorpanel.c:673
+msgid "Green"
+msgstr "Grien"
+
+#: ../../WINGs/wcolorpanel.c:704
+msgid "Blue"
+msgstr "Blau"
+
+#: ../../WINGs/wcolorpanel.c:718
+msgid "Decimal"
+msgstr "Desimaal"
+
+#: ../../WINGs/wcolorpanel.c:726
+msgid "Hexadecimal"
+msgstr "Heksadesimaal"
+
+#: ../../WINGs/wcolorpanel.c:779
+msgid "Cyan"
+msgstr "Cyaan"
+
+#: ../../WINGs/wcolorpanel.c:810
+msgid "Magenta"
+msgstr "Magenta"
+
+#: ../../WINGs/wcolorpanel.c:842
+msgid "Yellow"
+msgstr "Giel"
+
+#: ../../WINGs/wcolorpanel.c:875
+msgid "Black"
+msgstr "Swart"
+
+#: ../../WINGs/wcolorpanel.c:950
+msgid "Spectrum"
+msgstr "Spektrum"
+
+#: ../../WINGs/wcolorpanel.c:976
+msgid "Palette"
+msgstr "Palet"
+
+#: ../../WINGs/wcolorpanel.c:981
+msgid "New from File..."
+msgstr "Nij út bestân..."
+
+#: ../../WINGs/wcolorpanel.c:982 ../../WINGs/wcolorpanel.c:1027
+#: ../../WINGs/wcolorpanel.c:1042
+msgid "Rename..."
+msgstr "Omneame..."
+
+#: ../../WINGs/wcolorpanel.c:983 ../../WINGs/wcolorpanel.c:1028
+#: ../../WINGs/wcolorpanel.c:1043 ../../WINGs/wcolorpanel.c:3180
+msgid "Remove"
+msgstr "Ferwiderje"
+
+#: ../../WINGs/wcolorpanel.c:984
+msgid "Copy"
+msgstr "Kopiearje"
+
+#: ../../WINGs/wcolorpanel.c:985
+msgid "New from Clipboard"
+msgstr "Nij fan klamboerd"
+
+#: ../../WINGs/wcolorpanel.c:1004
+msgid "X11-Colors"
+msgstr "X11-kleuren"
+
+#: ../../WINGs/wcolorpanel.c:1021
+msgid "Color"
+msgstr "Kleur"
+
+#: ../../WINGs/wcolorpanel.c:1026
+msgid "Add..."
+msgstr "Tafoegje..."
+
+#: ../../WINGs/wcolorpanel.c:1036
+msgid "List"
+msgstr "List"
+
+#: ../../WINGs/wcolorpanel.c:1041
+msgid "New..."
+msgstr "Nij..."
+
+#: ../../WINGs/wcolorpanel.c:1170
+#, c-format
+msgid ""
+"Color Panel: Could not create directory %s needed to store configurations"
+msgstr ""
+"Kleurepaniel: Koe map %s, nedich om ynstellingen te bewarjen, net oanmeitsje"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1176 ../../WINGs/wcolorpanel.c:3073
+#: ../../WINGs/wcolorpanel.c:3077
+msgid "File Error"
+msgstr "Bestânsflater"
+
+#: ../../WINGs/wcolorpanel.c:1177
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Koe ynstellingemap Kleurepaniel net oanmeitsje"
+
+#: ../../WINGs/wcolorpanel.c:1178 ../../WINGs/wcolorpanel.c:3074
+#: ../../WINGs/wcolorpanel.c:3079 ../../WINGs/wcolorpanel.c:3104
+#: ../../WINGs/wfilepanel.c:227 ../../WINGs/wfilepanel.c:596
+#: ../../WINGs/wfilepanel.c:611 ../../WINGs/wfilepanel.c:715
+#: ../../WINGs/wfilepanel.c:883 ../../WINGs/wfontpanel.c:532
+msgid "OK"
+msgstr "OK"
+
+#: ../../WINGs/wcolorpanel.c:1184
+msgid "Color Panel: Could not find file"
+msgstr "Kleurepaniel: Koe bestân net fine"
+
+#: ../../WINGs/wcolorpanel.c:1380 ../../WINGs/wcolorpanel.c:1441
+#: ../../WINGs/wcolorpanel.c:1501
+msgid "Color Panel: X failed request"
+msgstr "Kleurepaniel: X-oanfraach mislearre"
+
+#: ../../WINGs/wcolorpanel.c:2754
+msgid "Saturation"
+msgstr "Fersêding"
+
+#: ../../WINGs/wcolorpanel.c:2788
+msgid "Hue"
+msgstr "Tint"
+
+#: ../../WINGs/wcolorpanel.c:3012
+msgid "Open Palette"
+msgstr "Iepenje palet"
+
+#: ../../WINGs/wcolorpanel.c:3074
+msgid "Invalid file format !"
+msgstr "Unjildige bestânsfoarm!"
+
+#: ../../WINGs/wcolorpanel.c:3076
+#, c-format
+msgid "can't remove file %s"
+msgstr "kin bestân %s net ferwiderje"
+
+#: ../../WINGs/wcolorpanel.c:3078
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Koe bestân net ferwiderje út ynstellingemap!"
+
+#: ../../WINGs/wcolorpanel.c:3103
+msgid "Rename"
+msgstr "Omneame"
+
+#: ../../WINGs/wcolorpanel.c:3103
+msgid "Rename palette to:"
+msgstr "Neam palet om nei:"
+
+#: ../../WINGs/wcolorpanel.c:3104 ../../WINGs/wfilepanel.c:236
+#: ../../WINGs/wfilepanel.c:611 ../../WINGs/wfilepanel.c:715
+msgid "Cancel"
+msgstr "Annulearje"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3120 ../../WINGs/wfilepanel.c:715
+msgid "Warning"
+msgstr "Warskôging"
+
+#: ../../WINGs/wcolorpanel.c:3121
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Palet bestiet al!\n"
+"\n"
+"Oerskriuwe?"
+
+#: ../../WINGs/wcolorpanel.c:3121 ../../WINGs/wcolorpanel.c:3180
+msgid "No"
+msgstr "Nee"
+
+#: ../../WINGs/wcolorpanel.c:3121 ../../WINGs/wcolorpanel.c:3180
+msgid "Yes"
+msgstr "Ja"
+
+#: ../../WINGs/wcolorpanel.c:3152
+#, c-format
+msgid "Couldn't rename palette %s to %s"
+msgstr "Koe palet %s net omneame nei %s"
+
+#: ../../WINGs/wcolorpanel.c:3175
+msgid "This will permanently remove the palette "
+msgstr "Dit sil it palet "
+
+#: ../../WINGs/wcolorpanel.c:3177
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+" definityf ferwiderje.\n"
+"\n"
+"Binne jo wis dat jo dit palet ferwiderje wolle?"
+
+#: ../../WINGs/wcolorpanel.c:3199
+#, c-format
+msgid "Couldn't remove palette %s"
+msgstr "Koe palet %s net ferwiderje"
+
+#: ../../WINGs/wcolorpanel.c:3499
+msgid "Color Panel: Color unspecified"
+msgstr "Kleurepaniel: Kleur net opjûn"
+
+#: ../../WINGs/wfilepanel.c:216
+msgid "Name:"
+msgstr "Namme:"
+
+#: ../../WINGs/wfilepanel.c:306 ../../WINGs/wfilepanel.c:364
+msgid "Open"
+msgstr "Iepenje"
+
+#: ../../WINGs/wfilepanel.c:322 ../../WINGs/wfilepanel.c:370
+msgid "Save"
+msgstr "Bewarje"
+
+#: ../../WINGs/wfilepanel.c:506
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: Koe map %s net iepenje\n"
+
+#: ../../WINGs/wfilepanel.c:526
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: Koe status %s net fêststelle\n"
+
+#: ../../WINGs/wfilepanel.c:596 ../../WINGs/wfilepanel.c:883
+#: ../../WINGs/wfontpanel.c:531
+msgid "Error"
+msgstr "Flater"
+
+#: ../../WINGs/wfilepanel.c:610
+msgid "Create Directory"
+msgstr "Map oanmeitsje"
+
+#: ../../WINGs/wfilepanel.c:611
+msgid "Enter directory name"
+msgstr "Fier mapnamme yn"
+
+#: ../../WINGs/wfilepanel.c:639
+#, c-format
+msgid "Can not create %s: %s"
+msgstr "Kin %s net oanmeitsje: %s"
+
+#: ../../WINGs/wfilepanel.c:705
+#, c-format
+msgid "Can not find %s: %s"
+msgstr "Kin %s net fine: %s"
+
+#: ../../WINGs/wfilepanel.c:711
+#, c-format
+msgid "Delete %s %s?"
+msgstr "%s %s ferwiderje?"
+
+#: ../../WINGs/wfilepanel.c:712
+msgid "directory"
+msgstr "Map"
+
+#: ../../WINGs/wfilepanel.c:712
+msgid "file"
+msgstr "Bestân"
+
+#: ../../WINGs/wfilepanel.c:719
+#, c-format
+msgid "Removing %s failed: %s"
+msgstr "Ferwiderjen %s mislearre: %s"
+
+#: ../../WINGs/wfilepanel.c:751
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Der trede in flater op by blêdzjen troch '%s'."
+
+#: ../../WINGs/wfilepanel.c:754
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "'%s' is gjin map."
+
+#: ../../WINGs/wfilepanel.c:883
+msgid "File does not exist."
+msgstr "Bestân bestiet net."
+
+#: ../../WINGs/wfont.c:43
+#, c-format
+msgid "invalid font: %s. Trying '%s'"
+msgstr "ûnjildich lettertype: %s. Probearret '%s'"
+
+#: ../../WINGs/wfont.c:260 ../../WINGs/wfont.c:278
+#, c-format
+msgid "could not load font: %s."
+msgstr "koe lettertype net lade: %s."
+
+#. WMSetWidgetBackgroundColor(panel->win, WMWhiteColor(scr));
+#: ../../WINGs/wfontpanel.c:184
+msgid "Font Panel"
+msgstr "Lettertypen"
+
+#: ../../WINGs/wfontpanel.c:220
+msgid "The quick brown fox jumps over the lazy dog"
+msgstr "De rappe brune foks springt oer de loaie hûn"
+
+#: ../../WINGs/wfontpanel.c:226
+msgid "Family"
+msgstr "Famylje"
+
+#: ../../WINGs/wfontpanel.c:237
+msgid "Typeface"
+msgstr "Lettertype"
+
+#: ../../WINGs/wfontpanel.c:248
+msgid "Size"
+msgstr "Grutte"
+
+#: ../../WINGs/wfontpanel.c:267
+msgid "Set"
+msgstr "Ynstelle"
+
+#: ../../WINGs/wfontpanel.c:273
+msgid "Revert"
+msgstr "Werstelle"
+
+#: ../../WINGs/wfontpanel.c:532
+msgid "Could not init font config library\n"
+msgstr "Koe biblioteek 'lettertype ynstelle' net inisjalisearje\n"
+
+#: ../../WINGs/widgets.c:446
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: Koe ôfbyldingebestân bestjoeringseleminten net lade: %s"
+
+#: ../../WINGs/widgets.c:542
+#, c-format
+msgid "WINGs: could not open display %s"
+msgstr "WINGs: Koe skerm %s net iepenje"
+
+#: ../../WINGs/widgets.c:771
+msgid ""
+"could not load any fonts. Make sure your font installation and locale "
+"settings are correct."
+msgstr ""
+"koe gjin lettertypen lade. Soargje derfoar dat jo ynstallearre lettertypen "
+"en lokalisaasjeynstellingen korrekt binne."
+
+#: ../../WINGs/winputmethod.c:65
+msgid "could not add destroy callback for XIM input method"
+msgstr ""
+
+#: ../../WINGs/wruler.c:175
+msgid "0   inches"
+msgstr "0   inch"
+
+#: ../../WINGs/wtextfield.c:494
+msgid "only left alignment is supported in textfields"
+msgstr "allinnich lofts rjochtsjen wurdt stipe yn tekstfjilden"
+
+#: ../../WINGs/wwindow.c:160
+msgid "window title conversion error... using STRING encoding"
+msgstr "finstertitelomsettingsflater... brûkt STRING-kodearring"
+
+#: ../../WINGs/wwindow.c:181
+msgid "icon title conversion error... using STRING encoding"
+msgstr "ikoantitelomsettingsflater... brûkt STRING-kodearring"

bazel/WINGs/po/hu.po

@@ -0,0 +1,606 @@
+# Hungarian Translation for WINGs
+# Copyright (C)2014 BALATON Zoltan
+# This file is distributed under the same license as WINGs.
+# BALATON Zoltán <balaton@eik.bme.hu>, 2014
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Window Maker 0.95.5\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-02-18 00:14+0100\n"
+"PO-Revision-Date: 2014-02-18 00:25+0100\n"
+"Last-Translator: BALATON Zoltán <balaton@eik.bme.hu>\n"
+"Language-Team: Hungarian\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../../../wmaker-crm/WINGs/error.c:117
+msgid "fatal: "
+msgstr "végzetes hiba: "
+
+#: ../../../wmaker-crm/WINGs/error.c:124
+msgid "error: "
+msgstr "hiba: "
+
+#: ../../../wmaker-crm/WINGs/error.c:131
+msgid "warning: "
+msgstr "figyelmeztetés: "
+
+#: ../../../wmaker-crm/WINGs/findfile.c:58
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "nem találtam jelszó bejegyzést a %i felhasználó azonosítóhoz"
+
+#: ../../../wmaker-crm/WINGs/findfile.c:87
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "nem találtam jelszó bejegyzést a \"%s\" nevű felhasználóhoz"
+
+#: ../../../wmaker-crm/WINGs/findfile.c:203
+#, c-format
+msgid "could not expand %s"
+msgstr "nem tudtam értelmezni: %s"
+
+#: ../../../wmaker-crm/WINGs/findfile.c:435
+#, c-format
+msgid "Could not open %s"
+msgstr "Nem sikerült megnyitni ezt: %s"
+
+#: ../../../wmaker-crm/WINGs/findfile.c:442
+#, c-format
+msgid "Could not create %s"
+msgstr "Nem sikerült létrehozni ezt: %s"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:78
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "formai hiba ebben: %s %s, %i. sor: %s"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:134
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr "proplist szótár kulcsa csak karakterlánc vagy adat típusú lehet"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:167
+#: ../../../wmaker-crm/WINGs/proplist.c:217
+#: ../../../wmaker-crm/WINGs/proplist.c:382
+#: ../../../wmaker-crm/WINGs/proplist.c:458
+#: ../../../wmaker-crm/WINGs/proplist.c:1048
+#: ../../../wmaker-crm/WINGs/proplist.c:1098
+#: ../../../wmaker-crm/WINGs/proplist.c:1245
+#: ../../../wmaker-crm/WINGs/proplist.c:1313
+#: ../../../wmaker-crm/WINGs/proplist.c:1418
+#: ../../../wmaker-crm/WINGs/proplist.c:1462
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr "proplist függvényt próbáltál használni nem WMPropList objektumon"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:635
+msgid "unterminated PropList string"
+msgstr "befejezetlen PropList karakterlánc"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:673
+msgid "unterminated PropList data"
+msgstr "befejezetlen PropList adat"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:681
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr "befejezetlen PropList adat (hiányzó hexa számjegy)"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:693
+#: ../../../wmaker-crm/WINGs/proplist.c:698
+msgid "non hexdigit character in PropList data"
+msgstr "nem hexa számjegy karakter PropList adaton belül"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:730
+msgid "unterminated PropList array"
+msgstr "befejezetlen PropList tömb"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:738
+msgid "missing or unterminated PropList array"
+msgstr "hiányzó vagy befejezetlen PropList tömb"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:748
+msgid "could not get PropList array element"
+msgstr "nem találom a PropList tömb elemét"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:775
+msgid "unterminated PropList dictionary"
+msgstr "befejezetlen PropList szótár"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:792
+msgid "missing PropList dictionary key"
+msgstr "hiányzó PropList szótár kulcs"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:794
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr "hiányzó PropList szótár kulcs vagy befejezetlen szótár"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:802
+msgid "error parsing PropList dictionary key"
+msgstr "hiba a PropList szótár kulcs értelmezése közben"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:810
+msgid "missing = in PropList dictionary entry"
+msgstr "hiányzó = a PropList szótár elemben"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:818
+msgid "error parsing PropList dictionary entry value"
+msgstr "hiba a PropList szótár elem értékenek értelmezése közben"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:826
+msgid "missing ; in PropList dictionary entry"
+msgstr "hiányzó ; a PropList szótár elemben"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:885
+msgid "was expecting a string, data, array or dictionary. If it's a string, try enclosing it with \"."
+msgstr "karakterlánc, adat, tömb vagy szótár típusra számítottam. Ha karakterláncot adtál meg, próbáld idézőjelbe tenni!"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:888
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "A Window Maker fájljaiban nem engedélyezettek a megjegyzések."
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1482
+#: ../../../wmaker-crm/WINGs/proplist.c:1547
+#: ../../../wmaker-crm/WINGs/proplist.c:1604
+msgid "extra data after end of property list"
+msgstr "extra adat a proplist vége után"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1522
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "nem tudtam lekérdezni a következő fájl méretet: '%s'"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1530
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "nem tudtam beolvasni a következő fájlt: '%s'"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1575
+#, c-format
+msgid "%s:could not open menu file"
+msgstr "%s: nem tudtam megnyitni a menü fájlt"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1642
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "mkstemp (%s) hibát adott"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1653
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "mktemp (%s) hibát adott"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1660
+#, c-format
+msgid "open (%s) failed"
+msgstr "open (%s) hibát adott"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1667
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "hiba a következő fájl írásakor: %s"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1676
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "fclose (%s) hibát adott"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1684
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "rename ('%s'-ről '%s'-re) hibát adott"
+
+#: ../../../wmaker-crm/WINGs/proplist.c:1755
+#, c-format
+msgid "Could not create component %s"
+msgstr "Nem sikerült létrehozni a %s elemet"
+
+#: ../../../wmaker-crm/WINGs/userdefaults.c:65
+msgid "variable WMAKER_USER_ROOT defined with invalid path, not used"
+msgstr "A WMAKER_USER_ROOT változó be van állítva, de rossz értékre. Nem használom"
+
+#. something happened with the file. just overwrite it
+#: ../../../wmaker-crm/WINGs/userdefaults.c:196
+#: ../../../wmaker-crm/WINGs/userdefaults.c:211
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "szinkronizálás közben nem tudtam a tartományt kiolvasni a '%s' fájlból"
+
+#: ../../../wmaker-crm/WINGs/wcolor.c:204
+#: ../../../wmaker-crm/WINGs/wcolor.c:214
+#: ../../../wmaker-crm/WINGs/wcolor.c:250
+#: ../../../wmaker-crm/WINGs/wcolor.c:288
+#, c-format
+msgid "could not allocate %s color"
+msgstr "nem sikerült lefoglalni ezt a színt: %s"
+
+#: ../../../wmaker-crm/WINGs/wcolor.c:204
+msgid "white"
+msgstr "fehér"
+
+#: ../../../wmaker-crm/WINGs/wcolor.c:214
+msgid "black"
+msgstr "fekete"
+
+#: ../../../wmaker-crm/WINGs/wcolor.c:250
+msgid "gray"
+msgstr "szürke"
+
+#: ../../../wmaker-crm/WINGs/wcolor.c:288
+msgid "dark gray"
+msgstr "sötétszürke"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:383
+msgid "Colors"
+msgstr "Színek"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:558
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2624
+msgid "Brightness"
+msgstr "Világosság"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:560
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:634
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:665
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:696
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:754
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:785
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:817
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:850
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1988
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2626
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2660
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2694
+msgid "Color Panel: Could not allocate memory"
+msgstr "Szín panel: nem sikerült a memória foglalás"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:632
+msgid "Red"
+msgstr "Piros"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:663
+msgid "Green"
+msgstr "Zöld"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:694
+msgid "Blue"
+msgstr "Kék"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:752
+msgid "Cyan"
+msgstr "Türkiz"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:783
+msgid "Magenta"
+msgstr "Lila"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:815
+msgid "Yellow"
+msgstr "Sárga"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:848
+msgid "Black"
+msgstr "Fekete"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:923
+msgid "Spectrum"
+msgstr "Spektrum"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:949
+msgid "Palette"
+msgstr "Paletta"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:954
+msgid "New from File..."
+msgstr "Új, fájlból..."
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:955
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1000
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1015
+msgid "Rename..."
+msgstr "Átnevez..."
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:956
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1001
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1016
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3086
+msgid "Remove"
+msgstr "Töröl"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:957
+msgid "Copy"
+msgstr "Másol"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:958
+msgid "New from Clipboard"
+msgstr "Új, vágólapról"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:977
+msgid "X11-Colors"
+msgstr "X11 színek"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:994
+msgid "Color"
+msgstr "Szín"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:999
+msgid "Add..."
+msgstr "Hozzáad..."
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1009
+msgid "List"
+msgstr "Lista"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1014
+msgid "New..."
+msgstr "Új..."
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1142
+#, c-format
+msgid "Color Panel: Could not create directory %s needed to store configurations"
+msgstr "Szín panel: Nem sikerült a beállítások tárolásához szükséges könyvtárat létrehozni: %s"
+
+#. Delete the file, it doesn't belong here
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1148
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2979
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2983
+msgid "File Error"
+msgstr "Fájl hiba"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1149
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Nem sikerült létrehozni a Szín panel beállítás könyvtárát"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1150
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2980
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2985
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3010
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:227
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:596
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:611
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:712
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:890
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:534
+msgid "OK"
+msgstr "OK"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1156
+msgid "Color Panel: Could not find file"
+msgstr "Szín panel: nem találom a fájlt"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1352
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1413
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:1473
+msgid "Color Panel: X failed request"
+msgstr "Szín panel: hibás X kérés"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2658
+msgid "Saturation"
+msgstr "Telítettség"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2692
+msgid "Hue"
+msgstr "Árnyalat"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2918
+msgid "Open Palette"
+msgstr "Paletta megnyitás"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2980
+msgid "Invalid file format !"
+msgstr "Érvénytelen fájl formátum!"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2982
+#, c-format
+msgid "can't remove file %s"
+msgstr "nem sikerült törölni a következő fált: %s"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:2984
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Nem sikerült törölni a fájlt a beállítás könyvtárból!"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3009
+msgid "Rename"
+msgstr "Átnevez"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3009
+msgid "Rename palette to:"
+msgstr "Paletta átnevezése erre:"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3010
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:236
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:611
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:712
+msgid "Cancel"
+msgstr "Mégsem"
+
+#. Careful, this palette exists already
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3026
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:712
+msgid "Warning"
+msgstr "Figyelem!"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3027
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Ez a paletta már létezik!\n"
+"\n"
+"Felülírjam?"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3027
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3086
+msgid "No"
+msgstr "Nem"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3027
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3086
+msgid "Yes"
+msgstr "Igen"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3058
+#, c-format
+msgid "Couldn't rename palette %s to %s"
+msgstr "Nem sikerült a paletta átnevezése %s-ről %s-re"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3081
+msgid "This will permanently remove the palette "
+msgstr "Ez véglegesen törli a következő palettát: "
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3083
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+".\n"
+"\n"
+"Biztosan törölni akarod ezt a palettát?"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3105
+#, c-format
+msgid "Couldn't remove palette %s"
+msgstr "Nem sikerült törölni ezt a palettát: %s"
+
+#: ../../../wmaker-crm/WINGs/wcolorpanel.c:3395
+msgid "Color Panel: Color unspecified"
+msgstr "Szín panel: nincs megadva szín"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:216
+msgid "Name:"
+msgstr "Név: "
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:306
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:364
+msgid "Open"
+msgstr "Megnyit"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:322
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:370
+msgid "Save"
+msgstr "Ment"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:506
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: nem tudom megnyitni a következő könyvtárat: %s\n"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:526
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: nem tudom lekérdezni a következő fájl adatait: %s\n"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:596
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:890
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:533
+msgid "Error"
+msgstr "Hiba"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:610
+msgid "Create Directory"
+msgstr "Új könyvtár"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:611
+msgid "Enter directory name"
+msgstr "Könyvtár neve"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:639
+#, c-format
+msgid "Can not create %s: %s"
+msgstr "Nem sikerült létrehozni: %s: %s"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:702
+#, c-format
+msgid "Can not find %s: %s"
+msgstr "Nem találom: %s: %s"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:708
+#, c-format
+msgid "Delete %s %s?"
+msgstr "Töröljem a következő %s: \"%s\"?"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:709
+msgid "directory"
+msgstr "könyvtárat"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:709
+msgid "file"
+msgstr "fájlt"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:716
+#, c-format
+msgid "Removing %s failed: %s"
+msgstr "Hiba \"%s\" törlésekor: %s"
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:749
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Hiba történt a '%s' olvasásakor."
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:752
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "Nem könyvtár: '%s'."
+
+#: ../../../wmaker-crm/WINGs/wfilepanel.c:890
+msgid "File does not exist."
+msgstr "Nem létező fájl."
+
+#: ../../../wmaker-crm/WINGs/wfont.c:37
+#, c-format
+msgid "invalid font: %s. Trying '%s'"
+msgstr "érvénytelen betűtípus: %s. Ezt próbálom helyette: '%s'"
+
+#: ../../../wmaker-crm/WINGs/wfont.c:227 ../../../wmaker-crm/WINGs/wfont.c:245
+#, c-format
+msgid "could not load font: %s."
+msgstr "nem tudtam betölteni ezt a betűtípust: %s."
+
+#. WMSetWidgetBackgroundColor(panel->win, WMWhiteColor(scr));
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:186
+msgid "Font Panel"
+msgstr "Betűtípus panel"
+
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:222
+msgid "The quick brown fox jumps over the lazy dog"
+msgstr "Árvíztűrő tükörfúrógép"
+
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:228
+msgid "Family"
+msgstr "Típuscsalád"
+
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:239
+msgid "Typeface"
+msgstr "Betűtípus"
+
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:250
+msgid "Size"
+msgstr "Méret"
+
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:269
+msgid "Set"
+msgstr "Beállít"
+
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:275
+msgid "Revert"
+msgstr "Elvet"
+
+#: ../../../wmaker-crm/WINGs/wfontpanel.c:534
+msgid "Could not init font config library\n"
+msgstr "Nem sikerült inicializálni a betűtípus konfigurációs könyvtárat\n"
+
+#: ../../../wmaker-crm/WINGs/widgets.c:389
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: nem tudtam betölteni a következő fájlt: %s"
+
+#: ../../../wmaker-crm/WINGs/widgets.c:724
+msgid "could not load any fonts. Make sure your font installation and locale settings are correct."
+msgstr "egyetlen betűtípust sem tudtam betölteni. Ellenőrizd a telepítést és a nemzetközi beállítások helyességét!"
+
+#: ../../../wmaker-crm/WINGs/wruler.c:175
+msgid "0   inches"
+msgstr "0   hüvelyk"

bazel/WINGs/po/nl.po

@@ -0,0 +1,876 @@
+# New translation into Dutch for Window Maker
+# Copyright (C) 2014-2019 Window Maker Developers Team
+# This file is distributed under the same license as the windowmaker package.
+# Original by Alwin <translations@ziggo.nl>, 2014.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: wmaker-0.95.6+\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-05-18 08:07+0200\n"
+"PO-Revision-Date: 2015-05-18 00:00+0000\n"
+"Last-Translator: Alwin <translations@ziggo.nl>\n"
+"Language-Team: Dutch\n"
+"Language: nl\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../../WINGs/error.c:106
+msgid "fatal: "
+msgstr "onherstelbaar: "
+
+#: ../../WINGs/error.c:112
+msgid "error: "
+msgstr "fout: "
+
+#: ../../WINGs/error.c:118
+msgid "warning: "
+msgstr "waarschuwing: "
+
+#: ../../WINGs/findfile.c:63
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "kon accountgegevens voor UID %i niet krijgen"
+
+#: ../../WINGs/findfile.c:93
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "kon accountgegevens voor gebruiker %s niet krijgen"
+
+#: ../../WINGs/findfile.c:212
+#, c-format
+msgid "could not expand %s"
+msgstr "kon %s niet uitwerken"
+
+#: ../../WINGs/findfile.c:441
+#, c-format
+msgid "Could not open input file \"%s\": %s"
+msgstr "Kon invoerbestand \"%s\" niet openen: %s"
+
+#: ../../WINGs/findfile.c:457
+#, c-format
+msgid "Could not create target file \"%s\": %s"
+msgstr "Kon doelbestand \"%s\" niet aanmaken: %s"
+
+#: ../../WINGs/findfile.c:465
+msgid "could not allocate memory for the copy buffer"
+msgstr "kon geheugen voor de kopiebuffer niet toewijzen"
+
+#: ../../WINGs/findfile.c:482
+#, c-format
+msgid "could not read from file \"%s\": %s"
+msgstr "kon bestand \"%s\" niet inlezen: %s"
+
+#: ../../WINGs/findfile.c:497
+#, c-format
+msgid "could not write data to file \"%s\": %s"
+msgstr "kon geen data schrijven naar bestand \"%s\": %s"
+
+#: ../../WINGs/findfile.c:509
+#, c-format
+msgid "could not set permission 0%03o on file \"%s\": %s"
+msgstr "kon toestemming 0%03o niet instellen op bestand \"%s\": %s"
+
+#: ../../WINGs/findfile.c:513
+#, c-format
+msgid "could not close the file \"%s\": %s"
+msgstr "kon bestand \"%s\" niet afsluiten: %s"
+
+#: ../../WINGs/menuparser.c:110
+#, c-format
+msgid "   included from file \"%s\" at line %d"
+msgstr "   ingevoegd uit bestand \"%s\" op regel %d"
+
+#: ../../WINGs/menuparser.c:142
+#, c-format
+msgid "missing #endif to match #%s at line %d"
+msgstr "ontbrekende #endif behorend bij #%s op regel %d"
+
+#: ../../WINGs/menuparser.c:200
+msgid "multiple SHORTCUT definition not valid"
+msgstr "meervoudige SHORTCUT-bepalingen niet geldig"
+
+#: ../../WINGs/menuparser.c:253
+msgid "premature end of file while expecting a new line after '\\'"
+msgstr "voortijdig bestandseinde, verwachtte 'n nieuwe regel na '\\'"
+
+#: ../../WINGs/menuparser.c:279
+#, c-format
+msgid "reached end of file while searching '*/' for comment started at line %d"
+msgstr ""
+"bestandseinde bereikt bij zoeken naar '*/' voor commentaar begonnen op regel "
+"%d"
+
+#: ../../WINGs/menuparser.c:344
+msgid "missing closing double-quote before end-of-line"
+msgstr "ontbrekend sluitend dubbel aanhalingsteken voor regeleinde"
+
+#: ../../WINGs/menuparser.c:362
+msgid "missing closing simple-quote before end-of-line"
+msgstr "ontbrekend sluitend enkel aanhalingsteken voor regeleinde"
+
+#: ../../WINGs/menuparser.c:380
+msgid "too many nested macro expansions, breaking loop"
+msgstr "te veel geneste macro-uitwerkingen, cyclus afgebroken"
+
+#: ../../WINGs/menuparser.c:439
+#, c-format
+msgid "unknown directive '#%s'"
+msgstr "onbekende aanwijzing '#%s'"
+
+#: ../../WINGs/menuparser.c:444
+#, c-format
+msgid "extra text after '#' command is ignored: \"%.16s...\""
+msgstr "extra tekst na #-commando wordt genegeerd: \"%.16s...\""
+
+#: ../../WINGs/menuparser.c:459
+msgid "no file name found for #include"
+msgstr "geen bestandsnaam gevonden voor #include"
+
+#: ../../WINGs/menuparser.c:471
+msgid "file name must be enclosed in brackets or double-quotes for #define"
+msgstr ""
+"bestandsnaam moet omsloten worden met haakjes of dubbele aanhalingstekens "
+"voor #define"
+
+#: ../../WINGs/menuparser.c:485
+#, c-format
+msgid "missing closing '%c' in filename specification"
+msgstr "ontbrekende sluitende '%c' in bestandsnaamopgave"
+
+#: ../../WINGs/menuparser.c:503
+msgid "too many nested #include's"
+msgstr "te veel geneste #include's"
+
+#: ../../WINGs/menuparser.c:568
+#, c-format
+msgid "could not find file \"%s\" for #include"
+msgstr "kon bestand \"%s\" niet vinden voor #include"
+
+#: ../../WINGs/menuparser.c:589
+#, c-format
+msgid "missing macro name argument to #%s"
+msgstr "ontbrekend macronaamargument bij #%s"
+
+#: ../../WINGs/menuparser.c:600
+msgid "too many nested #if sequences"
+msgstr "te veel geneste #if-reeksen"
+
+#: ../../WINGs/menuparser.c:626 ../../WINGs/menuparser.c:643
+#, c-format
+msgid "found #%s but has no matching #if"
+msgstr "#%s gevonden, maar heeft geen bijbehorende #if"
+
+#: ../../WINGs/menuparser_macros.c:166
+msgid "no macro name found for #define"
+msgstr "geen macronaam gevonden voor #define"
+
+#: ../../WINGs/menuparser_macros.c:187
+#, c-format
+msgid "premature end of file while reading arg-list for macro \"%s\""
+msgstr "voortijdig bestandseinde bij inlezen arg.-lijst voor macro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:194
+#, c-format
+msgid "too many parameters for macro \"%s\" definition"
+msgstr "te veel parameters voor bepaling macro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:209
+#, c-format
+msgid ""
+"invalid character '%c' in arg-list for macro \"%s\" while expecting "
+"parameter name"
+msgstr ""
+"ongeldig letterteken '%c' in arg.-lijst voor macro \"%s\", verwachtte "
+"parameternaam"
+
+#: ../../WINGs/menuparser_macros.c:220
+#, c-format
+msgid ""
+"invalid character '%c' in arg-list for macro \"%s\" while expecting ',' or "
+"')'"
+msgstr ""
+"ongeldig letterteken '%c' in arg.-lijst voor macro \"%s\", verwachtte ',' of "
+"')'"
+
+#: ../../WINGs/menuparser_macros.c:253
+#, c-format
+msgid "macro \"%s\" already defined, ignoring redefinition"
+msgstr "macro \"%s\" al gedefinieerd, negeert herdefiniëren"
+
+#: ../../WINGs/menuparser_macros.c:346
+#, c-format
+msgid "more content than supported for the macro \"%s\""
+msgstr "meer inhoud dan ondersteund voor macro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:455
+#, c-format
+msgid "expansion for macro \"%s\" too big, line truncated"
+msgstr "uitwerking voor macro \"%s\" te groot, regel ingekort"
+
+#: ../../WINGs/menuparser_macros.c:467
+#, c-format
+msgid "macro \"%s\" needs parenthesis for arguments"
+msgstr "macro \"%s\" heeft haakjes nodig voor argumenten"
+
+#: ../../WINGs/menuparser_macros.c:498
+msgid "missing closing quote or double-quote before end-of-line"
+msgstr "ontbrekend sluitend of dubbel aanhalingsteken voor regeleinde"
+
+#: ../../WINGs/menuparser_macros.c:521
+#, c-format
+msgid "too many arguments for macro \"%s\", expected only %d"
+msgstr "te veel argumenten voor macro \"%s\", verwachtte alleen %d"
+
+#: ../../WINGs/menuparser_macros.c:530
+#, c-format
+msgid "premature end of line while searching for arguments to macro \"%s\""
+msgstr "voortijdig regeleinde bij zoeken naar argumenten bij macro \"%s\""
+
+#: ../../WINGs/menuparser_macros.c:536
+#, c-format
+msgid "not enough arguments for macro \"%s\", expected %d but got only %d"
+msgstr ""
+"onvoldoende argumenten voor macro \"%s\", verwachtte %d, maar kreeg alleen %d"
+
+#: ../../WINGs/menuparser_macros.c:541
+#, c-format
+msgid "too much data in parameter list of macro \"%s\", truncated"
+msgstr "te veel data in parameterlijst van macro \"%s\", ingekort"
+
+#: ../../WINGs/menuparser_macros.c:561
+#, c-format
+msgid "size of value for macro '%s' is too big, truncated"
+msgstr "waarde voor macro '%s' is te lang, ingekort"
+
+#: ../../WINGs/menuparser_macros.c:642 ../../WINGs/menuparser_macros.c:668
+#, c-format
+msgid "could not determine %s"
+msgstr "kon %s niet vaststellen"
+
+#: ../../WINGs/proplist.c:78
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "syntaxfout in %s %s, regel %i: %s"
+
+#: ../../WINGs/proplist.c:134
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr ""
+
+#: ../../WINGs/proplist.c:167 ../../WINGs/proplist.c:217
+#: ../../WINGs/proplist.c:382 ../../WINGs/proplist.c:458
+#: ../../WINGs/proplist.c:1048 ../../WINGs/proplist.c:1098
+#: ../../WINGs/proplist.c:1246 ../../WINGs/proplist.c:1314
+#: ../../WINGs/proplist.c:1419 ../../WINGs/proplist.c:1463
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr ""
+
+#: ../../WINGs/proplist.c:635
+msgid "unterminated PropList string"
+msgstr ""
+
+#: ../../WINGs/proplist.c:673
+msgid "unterminated PropList data"
+msgstr ""
+
+#: ../../WINGs/proplist.c:681
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr ""
+
+#: ../../WINGs/proplist.c:693 ../../WINGs/proplist.c:698
+msgid "non hexdigit character in PropList data"
+msgstr ""
+
+#: ../../WINGs/proplist.c:730
+msgid "unterminated PropList array"
+msgstr ""
+
+#: ../../WINGs/proplist.c:738
+msgid "missing or unterminated PropList array"
+msgstr ""
+
+#: ../../WINGs/proplist.c:748
+msgid "could not get PropList array element"
+msgstr ""
+
+#: ../../WINGs/proplist.c:775
+msgid "unterminated PropList dictionary"
+msgstr ""
+
+#: ../../WINGs/proplist.c:792
+msgid "missing PropList dictionary key"
+msgstr ""
+
+# Geen chocola van te maken. ;-)
+#: ../../WINGs/proplist.c:794
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr ""
+
+#: ../../WINGs/proplist.c:802
+msgid "error parsing PropList dictionary key"
+msgstr ""
+
+#: ../../WINGs/proplist.c:810
+msgid "missing = in PropList dictionary entry"
+msgstr ""
+
+#: ../../WINGs/proplist.c:818
+msgid "error parsing PropList dictionary entry value"
+msgstr ""
+
+#: ../../WINGs/proplist.c:826
+msgid "missing ; in PropList dictionary entry"
+msgstr ""
+
+#: ../../WINGs/proplist.c:885
+msgid ""
+"was expecting a string, data, array or dictionary. If it's a string, try "
+"enclosing it with \"."
+msgstr ""
+
+#: ../../WINGs/proplist.c:888
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "Commentaar is niet toegestaan binnen domeinbestanden van WindowMaker."
+
+#: ../../WINGs/proplist.c:1483 ../../WINGs/proplist.c:1548
+#: ../../WINGs/proplist.c:1612
+msgid "extra data after end of property list"
+msgstr "extra data na einde van 'property list'"
+
+#: ../../WINGs/proplist.c:1523
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "kon grootte voor bestand '%s' niet krijgen"
+
+#: ../../WINGs/proplist.c:1531
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "fout bij inlezen bestand '%s'"
+
+#: ../../WINGs/proplist.c:1578
+#, c-format
+msgid "%s:could not open menu file"
+msgstr "%s:kon menubestand niet openen"
+
+#: ../../WINGs/proplist.c:1660
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "aanmaken uniek tijdelijk bestand (%s) mislukt"
+
+#: ../../WINGs/proplist.c:1670
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "aanmaken tijdelijk bestand (%s) mislukt"
+
+#: ../../WINGs/proplist.c:1677
+#, c-format
+msgid "open (%s) failed"
+msgstr "openen (%s) mislukt"
+
+#: ../../WINGs/proplist.c:1684
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "schrijven naar bestand: %s mislukt"
+
+#: ../../WINGs/proplist.c:1693
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "afsluiten stream (%s) mislukt"
+
+#: ../../WINGs/proplist.c:1701
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "hernoemen ('%s' naar '%s') mislukt"
+
+#: ../../WINGs/proplist.c:1772
+#, c-format
+msgid "Could not create component %s"
+msgstr "Kon component %s niet aanmaken"
+
+#: ../../WINGs/userdefaults.c:72
+msgid "variable WMAKER_USER_ROOT defined with invalid path, not used"
+msgstr ""
+"variabele WMAKER_USER_ROOT, gedefinieerd met ongeldig pad, niet gebruikt"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:210 ../../WINGs/userdefaults.c:225
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "kan domeinbestand '%s' niet inlezen bij synchroniseren"
+
+#: ../../WINGs/dragcommon.c:60
+#, c-format
+msgid "unknown XDND action %s"
+msgstr "onbekende XDND-actie %s"
+
+#: ../../WINGs/dragcommon.c:142
+#, c-format
+msgid "target %lu for XDND message no longer exists"
+msgstr "doel %lu voor XDND-bericht bestaat niet meer"
+
+#: ../../WINGs/dragcommon.c:220
+#, c-format
+msgid "unsupported version %i for XDND enter message"
+msgstr "niet-ondersteunde versie %i voor XDND-bericht bij binnengaan"
+
+#: ../../WINGs/dragsource.c:163
+msgid "XDND selection lost during drag operation..."
+msgstr "XDND-selectie verloren tijdens versleephandeling..."
+
+#: ../../WINGs/dragsource.c:758
+msgid "could not get XDND version for target of drop"
+msgstr "kon XDND-versie niet krijgen voor doel van verslepen"
+
+#: ../../WINGs/dragsource.c:774
+msgid "could not get ownership of XDND selection"
+msgstr "kon eigendom van XDND-selectie niet krijgen"
+
+#: ../../WINGs/dragsource.c:1070
+msgid "delay for drag destination response expired"
+msgstr "wachttijd voor antwoord versleepbestemming verstreken"
+
+#: ../../WINGs/wcolor.c:204 ../../WINGs/wcolor.c:214 ../../WINGs/wcolor.c:250
+#: ../../WINGs/wcolor.c:288
+#, c-format
+msgid "could not allocate %s color"
+msgstr "kon kleur %s niet toewijzen"
+
+#: ../../WINGs/wcolor.c:204
+msgid "white"
+msgstr "wit"
+
+#: ../../WINGs/wcolor.c:214
+msgid "black"
+msgstr "zwart"
+
+#: ../../WINGs/wcolor.c:250
+msgid "gray"
+msgstr "grijs"
+
+#: ../../WINGs/wcolor.c:288
+msgid "dark gray"
+msgstr "donkergrijs"
+
+#: ../../WINGs/wcolorpanel.c:393
+msgid "Colors"
+msgstr "Kleuren"
+
+#: ../../WINGs/wcolorpanel.c:568 ../../WINGs/wcolorpanel.c:2720
+msgid "Brightness"
+msgstr "Helderheid"
+
+#: ../../WINGs/wcolorpanel.c:570 ../../WINGs/wcolorpanel.c:644
+#: ../../WINGs/wcolorpanel.c:675 ../../WINGs/wcolorpanel.c:706
+#: ../../WINGs/wcolorpanel.c:781 ../../WINGs/wcolorpanel.c:812
+#: ../../WINGs/wcolorpanel.c:844 ../../WINGs/wcolorpanel.c:877
+#: ../../WINGs/wcolorpanel.c:2016 ../../WINGs/wcolorpanel.c:2722
+#: ../../WINGs/wcolorpanel.c:2756 ../../WINGs/wcolorpanel.c:2790
+msgid "Color Panel: Could not allocate memory"
+msgstr "Kleurenpaneel: Kon geen geheugen toewijzen"
+
+#: ../../WINGs/wcolorpanel.c:642
+msgid "Red"
+msgstr "Rood"
+
+#: ../../WINGs/wcolorpanel.c:673
+msgid "Green"
+msgstr "Groen"
+
+#: ../../WINGs/wcolorpanel.c:704
+msgid "Blue"
+msgstr "Blauw"
+
+#: ../../WINGs/wcolorpanel.c:718
+msgid "Decimal"
+msgstr "Decimaal"
+
+#: ../../WINGs/wcolorpanel.c:726
+msgid "Hexadecimal"
+msgstr "Hexadecimaal"
+
+#: ../../WINGs/wcolorpanel.c:779
+msgid "Cyan"
+msgstr "Cyaan"
+
+#: ../../WINGs/wcolorpanel.c:810
+msgid "Magenta"
+msgstr "Magenta"
+
+#: ../../WINGs/wcolorpanel.c:842
+msgid "Yellow"
+msgstr "Geel"
+
+#: ../../WINGs/wcolorpanel.c:875
+msgid "Black"
+msgstr "Zwart"
+
+#: ../../WINGs/wcolorpanel.c:950
+msgid "Spectrum"
+msgstr "Spectrum"
+
+#: ../../WINGs/wcolorpanel.c:976
+msgid "Palette"
+msgstr "Palet"
+
+#: ../../WINGs/wcolorpanel.c:981
+msgid "New from File..."
+msgstr "Nieuw uit bestand..."
+
+#: ../../WINGs/wcolorpanel.c:982 ../../WINGs/wcolorpanel.c:1027
+#: ../../WINGs/wcolorpanel.c:1042
+msgid "Rename..."
+msgstr "Hernoemen..."
+
+#: ../../WINGs/wcolorpanel.c:983 ../../WINGs/wcolorpanel.c:1028
+#: ../../WINGs/wcolorpanel.c:1043 ../../WINGs/wcolorpanel.c:3180
+msgid "Remove"
+msgstr "Verwijderen"
+
+#: ../../WINGs/wcolorpanel.c:984
+msgid "Copy"
+msgstr "Kopiëren"
+
+#: ../../WINGs/wcolorpanel.c:985
+msgid "New from Clipboard"
+msgstr "Nieuw van klembord"
+
+#: ../../WINGs/wcolorpanel.c:1004
+msgid "X11-Colors"
+msgstr "X11-kleuren"
+
+#: ../../WINGs/wcolorpanel.c:1021
+msgid "Color"
+msgstr "Kleur"
+
+#: ../../WINGs/wcolorpanel.c:1026
+msgid "Add..."
+msgstr "Toevoegen..."
+
+#: ../../WINGs/wcolorpanel.c:1036
+msgid "List"
+msgstr "Lijst"
+
+#: ../../WINGs/wcolorpanel.c:1041
+msgid "New..."
+msgstr "Nieuw..."
+
+#: ../../WINGs/wcolorpanel.c:1170
+#, c-format
+msgid ""
+"Color Panel: Could not create directory %s needed to store configurations"
+msgstr ""
+"Kleurenpaneel: Kon map %s, nodig om instellingen op te slaan, niet aanmaken"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1176 ../../WINGs/wcolorpanel.c:3073
+#: ../../WINGs/wcolorpanel.c:3077
+msgid "File Error"
+msgstr "Bestandsfout"
+
+#: ../../WINGs/wcolorpanel.c:1177
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Kon instellingenmap Kleurenpaneel niet aanmaken"
+
+#: ../../WINGs/wcolorpanel.c:1178 ../../WINGs/wcolorpanel.c:3074
+#: ../../WINGs/wcolorpanel.c:3079 ../../WINGs/wcolorpanel.c:3104
+#: ../../WINGs/wfilepanel.c:227 ../../WINGs/wfilepanel.c:596
+#: ../../WINGs/wfilepanel.c:611 ../../WINGs/wfilepanel.c:715
+#: ../../WINGs/wfilepanel.c:883 ../../WINGs/wfontpanel.c:532
+msgid "OK"
+msgstr "OK"
+
+#: ../../WINGs/wcolorpanel.c:1184
+msgid "Color Panel: Could not find file"
+msgstr "Kleurenpaneel: Kon bestand niet vinden"
+
+#: ../../WINGs/wcolorpanel.c:1380 ../../WINGs/wcolorpanel.c:1441
+#: ../../WINGs/wcolorpanel.c:1501
+msgid "Color Panel: X failed request"
+msgstr "Kleurenpaneel: X-aanvraag mislukt"
+
+#: ../../WINGs/wcolorpanel.c:2754
+msgid "Saturation"
+msgstr "Verzadiging"
+
+#: ../../WINGs/wcolorpanel.c:2788
+msgid "Hue"
+msgstr "Tint"
+
+#: ../../WINGs/wcolorpanel.c:3012
+msgid "Open Palette"
+msgstr "Open palet"
+
+#: ../../WINGs/wcolorpanel.c:3074
+msgid "Invalid file format !"
+msgstr "Ongeldige bestandsvorm!"
+
+#: ../../WINGs/wcolorpanel.c:3076
+#, c-format
+msgid "can't remove file %s"
+msgstr "kan bestand %s niet verwijderen"
+
+#: ../../WINGs/wcolorpanel.c:3078
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Kon bestand niet verwijderen uit instellingenmap!"
+
+#: ../../WINGs/wcolorpanel.c:3103
+msgid "Rename"
+msgstr "Hernoemen"
+
+#: ../../WINGs/wcolorpanel.c:3103
+msgid "Rename palette to:"
+msgstr "Hernoem palet naar:"
+
+#: ../../WINGs/wcolorpanel.c:3104 ../../WINGs/wfilepanel.c:236
+#: ../../WINGs/wfilepanel.c:611 ../../WINGs/wfilepanel.c:715
+msgid "Cancel"
+msgstr "Annuleren"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3120 ../../WINGs/wfilepanel.c:715
+msgid "Warning"
+msgstr "Waarschuwing"
+
+#: ../../WINGs/wcolorpanel.c:3121
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Palet bestaat al!\n"
+"\n"
+"Overschrijven?"
+
+#: ../../WINGs/wcolorpanel.c:3121 ../../WINGs/wcolorpanel.c:3180
+msgid "No"
+msgstr "Nee"
+
+#: ../../WINGs/wcolorpanel.c:3121 ../../WINGs/wcolorpanel.c:3180
+msgid "Yes"
+msgstr "Ja"
+
+#: ../../WINGs/wcolorpanel.c:3152
+#, c-format
+msgid "Couldn't rename palette %s to %s"
+msgstr "Kon palet %s niet hernoemen naar %s"
+
+#: ../../WINGs/wcolorpanel.c:3175
+msgid "This will permanently remove the palette "
+msgstr "Dit zal 't palet "
+
+#: ../../WINGs/wcolorpanel.c:3177
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+" definitief verwijderen.\n"
+"\n"
+"Weet u zeker dat u dit palet wilt verwijderen?"
+
+#: ../../WINGs/wcolorpanel.c:3199
+#, c-format
+msgid "Couldn't remove palette %s"
+msgstr "Kon palet %s niet verwijderen"
+
+#: ../../WINGs/wcolorpanel.c:3499
+msgid "Color Panel: Color unspecified"
+msgstr "Kleurenpaneel: Kleur niet opgegeven"
+
+#: ../../WINGs/wfilepanel.c:216
+msgid "Name:"
+msgstr "Naam:"
+
+#: ../../WINGs/wfilepanel.c:306 ../../WINGs/wfilepanel.c:364
+msgid "Open"
+msgstr "Openen"
+
+#: ../../WINGs/wfilepanel.c:322 ../../WINGs/wfilepanel.c:370
+msgid "Save"
+msgstr "Opslaan"
+
+#: ../../WINGs/wfilepanel.c:506
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: Kon map %s niet openen\n"
+
+#: ../../WINGs/wfilepanel.c:526
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: Kon status %s niet vaststellen\n"
+
+#: ../../WINGs/wfilepanel.c:596 ../../WINGs/wfilepanel.c:883
+#: ../../WINGs/wfontpanel.c:531
+msgid "Error"
+msgstr "Fout"
+
+#: ../../WINGs/wfilepanel.c:610
+msgid "Create Directory"
+msgstr "Map aanmaken"
+
+#: ../../WINGs/wfilepanel.c:611
+msgid "Enter directory name"
+msgstr "Voer mapnaam in"
+
+#: ../../WINGs/wfilepanel.c:639
+#, c-format
+msgid "Can not create %s: %s"
+msgstr "Kan %s niet aanmaken: %s"
+
+#: ../../WINGs/wfilepanel.c:705
+#, c-format
+msgid "Can not find %s: %s"
+msgstr "Kan %s niet vinden: %s"
+
+#: ../../WINGs/wfilepanel.c:711
+#, c-format
+msgid "Delete %s %s?"
+msgstr "%s %s verwijderen?"
+
+#: ../../WINGs/wfilepanel.c:712
+msgid "directory"
+msgstr "Map"
+
+#: ../../WINGs/wfilepanel.c:712
+msgid "file"
+msgstr "Bestand"
+
+#: ../../WINGs/wfilepanel.c:719
+#, c-format
+msgid "Removing %s failed: %s"
+msgstr "Verwijderen %s mislukt: %s"
+
+#: ../../WINGs/wfilepanel.c:751
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Er trad 'n fout op bij bladeren door '%s'."
+
+#: ../../WINGs/wfilepanel.c:754
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "'%s' is geen map."
+
+#: ../../WINGs/wfilepanel.c:883
+msgid "File does not exist."
+msgstr "Bestand bestaat niet."
+
+#: ../../WINGs/wfont.c:43
+#, c-format
+msgid "invalid font: %s. Trying '%s'"
+msgstr "ongeldig lettertype: %s. Probeert '%s'"
+
+#: ../../WINGs/wfont.c:260 ../../WINGs/wfont.c:278
+#, c-format
+msgid "could not load font: %s."
+msgstr "kon lettertype niet laden: %s."
+
+#. WMSetWidgetBackgroundColor(panel->win, WMWhiteColor(scr));
+#: ../../WINGs/wfontpanel.c:184
+msgid "Font Panel"
+msgstr "Lettertypen"
+
+#: ../../WINGs/wfontpanel.c:220
+msgid "The quick brown fox jumps over the lazy dog"
+msgstr "De snelle bruine vos springt over de luie hond"
+
+#: ../../WINGs/wfontpanel.c:226
+msgid "Family"
+msgstr "Familie"
+
+#: ../../WINGs/wfontpanel.c:237
+msgid "Typeface"
+msgstr "Lettertype"
+
+#: ../../WINGs/wfontpanel.c:248
+msgid "Size"
+msgstr "Grootte"
+
+#: ../../WINGs/wfontpanel.c:267
+msgid "Set"
+msgstr "Instellen"
+
+#: ../../WINGs/wfontpanel.c:273
+msgid "Revert"
+msgstr "Herstellen"
+
+#: ../../WINGs/wfontpanel.c:532
+msgid "Could not init font config library\n"
+msgstr "Kon bibliotheek 'lettertype instellen' niet initialiseren\n"
+
+#: ../../WINGs/widgets.c:446
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: Kon afbeeldingenbestand besturingselementen niet laden: %s"
+
+#: ../../WINGs/widgets.c:542
+#, c-format
+msgid "WINGs: could not open display %s"
+msgstr "WINGs: Kon scherm %s niet openen"
+
+#: ../../WINGs/widgets.c:771
+msgid ""
+"could not load any fonts. Make sure your font installation and locale "
+"settings are correct."
+msgstr ""
+"kon geen lettertypen laden. Zorg ervoor dat uw geïnstalleerde lettertypen en "
+"lokalisatie-instellingen juist zijn."
+
+#: ../../WINGs/winputmethod.c:65
+msgid "could not add destroy callback for XIM input method"
+msgstr ""
+
+#: ../../WINGs/wruler.c:175
+msgid "0   inches"
+msgstr "0   inch"
+
+#: ../../WINGs/wtextfield.c:494
+msgid "only left alignment is supported in textfields"
+msgstr "alleen links uitlijnen wordt ondersteund in tekstvelden"
+
+#: ../../WINGs/wwindow.c:160
+msgid "window title conversion error... using STRING encoding"
+msgstr "venstertitelomzettingsfout... gebruikt STRING-codering"
+
+#: ../../WINGs/wwindow.c:181
+msgid "icon title conversion error... using STRING encoding"
+msgstr "icoontitelomzettingsfout... gebruikt STRING-codering"
+
+# Keep next entries for wmaker-0.95.6
+msgid "Could not open input file \"%s\""
+msgstr "Kon invoerbestand \"%s\" niet openen"
+
+msgid "Could not create target file \"%s\""
+msgstr "Kon doelbestand \"%s\" niet aanmaken"
+
+msgid "An error occured browsing '%s'."
+msgstr "Er trad 'n fout op bij bladeren door '%s'."
+
+msgid ""
+"invalid characted '%c' in arg-list for macro \"%s\" while expecting "
+"parameter name"
+msgstr ""
+"ongeldig letterteken '%c' in arg.-lijst voor macro \"%s\", verwachtte "
+"parameternaam"
+
+msgid ""
+"invalid characted '%c' in arg-list for macro \"%s\" while expecting ',' "
+"or ')'"
+msgstr ""
+"ongeldig letterteken '%c' in arg.-lijst voor macro \"%s\", verwachtte ',' "
+"of ')'"
+
+msgid "unknow directive '#%s'"
+msgstr "onbekende aanwijzing '#%s'"
+
+msgid "found #%s but have no matching #if"
+msgstr "#%s gevonden, maar heeft geen bijbehorende #if"
+
+msgid "too many nested includes"
+msgstr "te veel geneste #include's"
+
+msgid "could not find file \"%s\" for include"
+msgstr "kon bestand \"%s\" niet vinden voor #include"
+
+msgid "too many nested macro expansion, breaking loop"
+msgstr "te veel geneste macro-uitwerkingen, cyclus afgebroken"

bazel/WINGs/po/sk.po

@@ -0,0 +1,719 @@
+# Slovak messages for WINGs
+# (C) 2001 Jan "judas" Tomka
+#
+# Original translation by Jan "judas" Tomka on Feb 25 2001
+# Currently maintained by Jan "judas" Tomka <judas@linux.sk>
+#
+# Version history:
+# 	WM-ver	author			email			date
+# 	0.65.1	Jan "judas" Tomka	<judas@linux.sk>	Aug 08 2001
+# 	0.70.0	Jan "judas" Tomka	<judas@linux.sk>	Oct 15 2001
+# 	0.70.1	Jan "judas" Tomka	<judas@linux.sk>	Nov 02 2001
+# 	0.80.0	Jan "judas" Tomka	<judas@linux.sk>	Dec 20 2001
+# 	0.80.2	Jan "judas" Tomka	<judas@linux.sk>	Jan 31 2004
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: WINGs 0.80.0\n"
+"POT-Creation-Date: 2004-01-31 18:36+0100\n"
+"PO-Revision-Date: 2001-12-20 04:00+0100\n"
+"Last-Translator: Jan \"judas\" Tomka <judas@linux.sk>\n"
+"Language-Team: Slovak <sk@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../../WINGs/connection.c:467 ../../WINGs/connection.c:532
+#: ../../WINGs/connection.c:575
+msgid "Bad address-service-protocol combination"
+msgstr "Nesprávna kombinácia adresa-služba-protokol"
+
+#: ../../WINGs/error.c:54
+#, c-format
+msgid "Unknown error %d"
+msgstr "Nezmána chyba %d"
+
+#: ../../WINGs/error.c:59
+#, c-format
+msgid "Error %d"
+msgstr "Chyba %d"
+
+#: ../../WINGs/error.c:110
+msgid "warning: "
+msgstr "varovanie: "
+
+#: ../../WINGs/error.c:137
+msgid "fatal: "
+msgstr "fatálna chyba: "
+
+#: ../../WINGs/error.c:163 ../../WINGs/error.c:192
+msgid "error: "
+msgstr "chyba: "
+
+#: ../../WINGs/findfile.c:48
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "nemožno zistiť informácie o UID %i"
+
+#: ../../WINGs/findfile.c:66
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "nemožno zistiť informácie o užívateľovi %s"
+
+#: ../../WINGs/host.c:114
+msgid "Cannot get current host name"
+msgstr "Nemožno zistiť aktuálne meno počítača"
+
+#: ../../WINGs/proplist.c:91
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "chyba syntaxe v %s %s, riadok %i: %s"
+
+#: ../../WINGs/proplist.c:150
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr "Pre kľúč slovníka proplist je podporovaný len reťazec alebo dáta"
+
+#: ../../WINGs/proplist.c:184 ../../WINGs/proplist.c:236
+#: ../../WINGs/proplist.c:394 ../../WINGs/proplist.c:474
+#: ../../WINGs/proplist.c:1075 ../../WINGs/proplist.c:1127
+#: ../../WINGs/proplist.c:1293 ../../WINGs/proplist.c:1372
+#: ../../WINGs/proplist.c:1493 ../../WINGs/proplist.c:1540
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr "Použitá proplist funkcia na iných ako WMPropLists objektoch"
+
+#: ../../WINGs/proplist.c:630
+msgid "unterminated PropList string"
+msgstr "neukončený PropList reťazec"
+
+#: ../../WINGs/proplist.c:670
+msgid "unterminated PropList data"
+msgstr "neukončené PropList dáta"
+
+#: ../../WINGs/proplist.c:678
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr "neukončené PropList dáta (chýbajúca hex číslica)"
+
+#: ../../WINGs/proplist.c:690 ../../WINGs/proplist.c:695
+msgid "non hexdigit character in PropList data"
+msgstr "v PropList dátach je znak, ktorý nie je hex číslicou"
+
+#: ../../WINGs/proplist.c:729
+msgid "unterminated PropList array"
+msgstr "neukončené PropList pole"
+
+#: ../../WINGs/proplist.c:737
+msgid "missing or unterminated PropList array"
+msgstr "chýbajúce alebo neukončené PropList pole"
+
+#: ../../WINGs/proplist.c:747
+msgid "could not get PropList array element"
+msgstr "nemožno zistiť prvok PropList poľa"
+
+#: ../../WINGs/proplist.c:776
+msgid "unterminated PropList dictionary"
+msgstr "neukončený PropList slovník"
+
+#: ../../WINGs/proplist.c:793
+msgid "missing PropList dictionary key"
+msgstr "chýbajúci kľúč PropList slovníka"
+
+#: ../../WINGs/proplist.c:795
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr "chýbajúci kľúč položky PropList slovníka alebo neukončený slovník"
+
+#: ../../WINGs/proplist.c:803
+msgid "error parsing PropList dictionary key"
+msgstr "chyba pri parsovaní kľúča PropList slovníka"
+
+#: ../../WINGs/proplist.c:811
+msgid "missing = in PropList dictionary entry"
+msgstr "chýbajúce = v položke PropList slovníka"
+
+#: ../../WINGs/proplist.c:819
+msgid "error parsing PropList dictionary entry value"
+msgstr "chyba pri parsovaní hodnoty položky PropList slovníka"
+
+#: ../../WINGs/proplist.c:827
+msgid "missing ; in PropList dictionary entry"
+msgstr "chýbajúca ; v položke PropList slovníka"
+
+#: ../../WINGs/proplist.c:888
+msgid ""
+"was expecting a string, data, array or dictionary. If it's a string, try "
+"enclosing it with \"."
+msgstr ""
+"očakávaný bol reťazec, dáta, pole alebo slovník. Ak je to reťazec, skúste ho "
+"uzavrieť medzi \"."
+
+#: ../../WINGs/proplist.c:892
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "Komentáre v doménových súboroch Window Makera nie sú povolené."
+
+#: ../../WINGs/proplist.c:1563 ../../WINGs/proplist.c:1630
+msgid "extra data after end of property list"
+msgstr "prebytočné dáta na konci property listu"
+
+#: ../../WINGs/proplist.c:1606
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "nemožno zistiť veľkosť súboru '%s'"
+
+#: ../../WINGs/proplist.c:1619
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "chyba pri čítaní zo súboru '%s'"
+
+#: ../../WINGs/proplist.c:1671
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "chyba mkstemp (%s)"
+
+#: ../../WINGs/proplist.c:1682
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "chyba mktemp(%s)"
+
+#: ../../WINGs/proplist.c:1693
+#, c-format
+msgid "open (%s) failed"
+msgstr "chyba pri otváraní (%s)"
+
+#: ../../WINGs/proplist.c:1700
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "chyba pri zápise do súboru: %s"
+
+#: ../../WINGs/proplist.c:1708
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "chyba fclose (%s)"
+
+#: ../../WINGs/proplist.c:1717
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "chyba rename ('%s' na '%s')"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:188 ../../WINGs/userdefaults.c:204
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "nemožno čítať doménu zo súboru '%s' pri synchronizácii"
+
+#: ../../WINGs/wcolor.c:224 ../../WINGs/wcolor.c:236 ../../WINGs/wcolor.c:275
+#: ../../WINGs/wcolor.c:316
+#, c-format
+msgid "could not allocate %s color"
+msgstr "nemožno alokovať %s farbu"
+
+#: ../../WINGs/wcolor.c:224
+msgid "white"
+msgstr "bielu"
+
+#: ../../WINGs/wcolor.c:236
+msgid "black"
+msgstr "čiernu"
+
+#: ../../WINGs/wcolor.c:275
+msgid "gray"
+msgstr "šedú"
+
+#: ../../WINGs/wcolor.c:316
+msgid "dark gray"
+msgstr "tmavošedú"
+
+#: ../../WINGs/wcolorpanel.c:420
+msgid "Colors"
+msgstr "Farby"
+
+#: ../../WINGs/wcolorpanel.c:610 ../../WINGs/wcolorpanel.c:2829
+msgid "Brightness"
+msgstr "Svetlosť"
+
+#: ../../WINGs/wcolorpanel.c:612 ../../WINGs/wcolorpanel.c:688
+#: ../../WINGs/wcolorpanel.c:721 ../../WINGs/wcolorpanel.c:755
+#: ../../WINGs/wcolorpanel.c:815 ../../WINGs/wcolorpanel.c:849
+#: ../../WINGs/wcolorpanel.c:883 ../../WINGs/wcolorpanel.c:918
+#: ../../WINGs/wcolorpanel.c:2169 ../../WINGs/wcolorpanel.c:2831
+#: ../../WINGs/wcolorpanel.c:2867 ../../WINGs/wcolorpanel.c:2903
+#: ../../WINGs/wcolorpanel.c:3745
+msgid "Color Panel: Could not allocate memory"
+msgstr "Panel farieb: Nemožno alokovať pamäť"
+
+#: ../../WINGs/wcolorpanel.c:685 ../../WINGs/wcolorpanel.c:686
+msgid "Red"
+msgstr "Červená"
+
+#: ../../WINGs/wcolorpanel.c:718 ../../WINGs/wcolorpanel.c:719
+msgid "Green"
+msgstr "Zelená"
+
+#: ../../WINGs/wcolorpanel.c:752 ../../WINGs/wcolorpanel.c:753
+msgid "Blue"
+msgstr "Modrá"
+
+#: ../../WINGs/wcolorpanel.c:812 ../../WINGs/wcolorpanel.c:813
+msgid "Cyan"
+msgstr "Azúrová"
+
+#: ../../WINGs/wcolorpanel.c:846 ../../WINGs/wcolorpanel.c:847
+msgid "Magenta"
+msgstr "Purpurová"
+
+#: ../../WINGs/wcolorpanel.c:880 ../../WINGs/wcolorpanel.c:881
+msgid "Yellow"
+msgstr "Žltá"
+
+#: ../../WINGs/wcolorpanel.c:915 ../../WINGs/wcolorpanel.c:916
+msgid "Black"
+msgstr "Čierna"
+
+#: ../../WINGs/wcolorpanel.c:996
+msgid "Spectrum"
+msgstr "Spektrum"
+
+#: ../../WINGs/wcolorpanel.c:1026
+msgid "Palette"
+msgstr "Paleta"
+
+#: ../../WINGs/wcolorpanel.c:1032
+msgid "New from File..."
+msgstr "Nová zo súboru..."
+
+#: ../../WINGs/wcolorpanel.c:1033 ../../WINGs/wcolorpanel.c:1081
+#: ../../WINGs/wcolorpanel.c:1098
+msgid "Rename..."
+msgstr "Premenovať..."
+
+#: ../../WINGs/wcolorpanel.c:1034 ../../WINGs/wcolorpanel.c:1082
+#: ../../WINGs/wcolorpanel.c:1099 ../../WINGs/wcolorpanel.c:3326
+msgid "Remove"
+msgstr "Odstrániť"
+
+#: ../../WINGs/wcolorpanel.c:1035
+msgid "Copy"
+msgstr "Kopírovať"
+
+#: ../../WINGs/wcolorpanel.c:1036
+msgid "New from Clipboard"
+msgstr "Nová z nástenky"
+
+#: ../../WINGs/wcolorpanel.c:1057
+msgid "X11-Colors"
+msgstr "Farby X11"
+
+#: ../../WINGs/wcolorpanel.c:1074
+msgid "Color"
+msgstr "Farba"
+
+#: ../../WINGs/wcolorpanel.c:1080
+msgid "Add..."
+msgstr "Pridať..."
+
+#: ../../WINGs/wcolorpanel.c:1090
+msgid "List"
+msgstr "Zoznam"
+
+#: ../../WINGs/wcolorpanel.c:1097
+msgid "New..."
+msgstr "Nový..."
+
+#: ../../WINGs/wcolorpanel.c:1236
+#, c-format
+msgid ""
+"Color Panel: Could not create directory %s needed to store configurations"
+msgstr ""
+"Panel farieb: Nemožno vytvoriť adresár %s potrebný na uloženie nastavení"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1242 ../../WINGs/wcolorpanel.c:3212
+#: ../../WINGs/wcolorpanel.c:3216
+msgid "File Error"
+msgstr "Chyba súboru"
+
+#: ../../WINGs/wcolorpanel.c:1243
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Nemožno vytvoriť konfiguračný adresár panelu farieb"
+
+#: ../../WINGs/wcolorpanel.c:1244 ../../WINGs/wcolorpanel.c:3213
+#: ../../WINGs/wcolorpanel.c:3218 ../../WINGs/wcolorpanel.c:3245
+#: ../../WINGs/wfilepanel.c:250 ../../WINGs/wfilepanel.c:650
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+#: ../../WINGs/wfilepanel.c:974 ../../WINGs/wfontpanel.c:751
+msgid "OK"
+msgstr "OK"
+
+#: ../../WINGs/wcolorpanel.c:1250 ../../WINGs/wcolorpanel.c:1286
+#: ../../WINGs/wcolorpanel.c:1304
+msgid "Color Panel: Could not find file"
+msgstr "Panel farieb: Nemožno nájsť súbor"
+
+#: ../../WINGs/wcolorpanel.c:1491 ../../WINGs/wcolorpanel.c:1556
+#: ../../WINGs/wcolorpanel.c:1620
+msgid "Color Panel: X failed request"
+msgstr "Panel farieb: chyba požiadavky X"
+
+#: ../../WINGs/wcolorpanel.c:2865
+msgid "Saturation"
+msgstr "Saturácia"
+
+#: ../../WINGs/wcolorpanel.c:2901
+msgid "Hue"
+msgstr "Odtieň"
+
+#: ../../WINGs/wcolorpanel.c:3151
+msgid "Open Palette"
+msgstr "Otvoriť paletu"
+
+#: ../../WINGs/wcolorpanel.c:3213
+msgid "Invalid file format !"
+msgstr "Nesprávny súborový formát!"
+
+#: ../../WINGs/wcolorpanel.c:3215
+#, c-format
+msgid "can't remove file %s"
+msgstr "namožno odstrániť súbor %s"
+
+#: ../../WINGs/wcolorpanel.c:3217
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Nemožno odstrániť súbor z konfiguračného adresára!"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename"
+msgstr "Premenovať"
+
+#: ../../WINGs/wcolorpanel.c:3244
+msgid "Rename palette to:"
+msgstr "Premenovať paletu:"
+
+#: ../../WINGs/wcolorpanel.c:3245 ../../WINGs/wfilepanel.c:259
+#: ../../WINGs/wfilepanel.c:662 ../../WINGs/wfilepanel.c:763
+msgid "Cancel"
+msgstr "Zrušiť"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3261 ../../WINGs/wfilepanel.c:763
+msgid "Warning"
+msgstr "Varovanie"
+
+#: ../../WINGs/wcolorpanel.c:3262
+msgid ""
+"Palette already exists !\n"
+"\n"
+"Overwrite ?"
+msgstr ""
+"Paleta už existuje!\n"
+"\n"
+"Prepísať?"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "No"
+msgstr "Nie"
+
+#: ../../WINGs/wcolorpanel.c:3262 ../../WINGs/wcolorpanel.c:3326
+msgid "Yes"
+msgstr "Áno"
+
+#: ../../WINGs/wcolorpanel.c:3294
+#, c-format
+msgid "Couldn't rename palette %s to %s\n"
+msgstr "Nemožno premenovať paletu %s na %s\n"
+
+#: ../../WINGs/wcolorpanel.c:3320
+msgid "This will permanently remove the palette "
+msgstr "Paleta bude natrvalo zmazaná"
+
+#: ../../WINGs/wcolorpanel.c:3323
+msgid ""
+".\n"
+"\n"
+"Are you sure you want to remove this palette ?"
+msgstr ""
+".\n"
+"\n"
+"Ste si istý, že chcete odstrániť túto paletu?"
+
+#: ../../WINGs/wcolorpanel.c:3348
+#, c-format
+msgid "Couldn't remove palette %s\n"
+msgstr "Nemožno odstrániť paletu %s\n"
+
+#: ../../WINGs/wcolorpanel.c:3647
+#, c-format
+msgid "Could not open %s"
+msgstr "Nemožno otvoriť %s"
+
+#: ../../WINGs/wcolorpanel.c:3654
+#, c-format
+msgid "Could not create %s"
+msgstr "Nemožno vytvoriť %s"
+
+#: ../../WINGs/wcolorpanel.c:3665
+#, c-format
+msgid "Write error on file %s"
+msgstr "Chyba zápisu do súboru %s"
+
+#: ../../WINGs/wcolorpanel.c:3710
+msgid "Color Panel: Color unspecified"
+msgstr "Panel farieb: Nešpecifikovaná farba"
+
+#: ../../WINGs/wfilepanel.c:235
+msgid "Name:"
+msgstr "Meno:"
+
+#: ../../WINGs/wfilepanel.c:332 ../../WINGs/wfilepanel.c:396
+msgid "Open"
+msgstr "Otvoriť"
+
+#: ../../WINGs/wfilepanel.c:350 ../../WINGs/wfilepanel.c:402
+msgid "Save"
+msgstr "Uložiť"
+
+#: ../../WINGs/wfilepanel.c:565
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: nemožno otvoriť adresár %s\n"
+
+#: ../../WINGs/wfilepanel.c:583
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: nemožno zistiť informácie o %s\n"
+
+#: ../../WINGs/wfilepanel.c:650 ../../WINGs/wfilepanel.c:973
+#: ../../WINGs/wfontpanel.c:750
+msgid "Error"
+msgstr "Chyba"
+
+#: ../../WINGs/wfilepanel.c:661
+msgid "Create Directory"
+msgstr "Vytvoriť adresár"
+
+#: ../../WINGs/wfilepanel.c:662
+msgid "Enter directory name"
+msgstr "Meno adresára"
+
+#: ../../WINGs/wfilepanel.c:698 ../../WINGs/wfilepanel.c:737
+#: ../../WINGs/wfilepanel.c:768 ../../WINGs/wfilepanel.c:796
+msgid "Permission denied."
+msgstr "Prístup zamietnutý."
+
+#: ../../WINGs/wfilepanel.c:701
+#, c-format
+msgid "'%s' already exists."
+msgstr "'%s' už existuje"
+
+#: ../../WINGs/wfilepanel.c:704
+msgid "Path does not exist."
+msgstr "Cesta neexistuje."
+
+#: ../../WINGs/wfilepanel.c:734 ../../WINGs/wfilepanel.c:793
+#, c-format
+msgid "'%s' does not exist."
+msgstr "'%s' neexistuje."
+
+#: ../../WINGs/wfilepanel.c:741 ../../WINGs/wfilepanel.c:800
+msgid "Insufficient memory available."
+msgstr "Nedostatok pamäti."
+
+#: ../../WINGs/wfilepanel.c:745 ../../WINGs/wfilepanel.c:804
+#, c-format
+msgid "'%s' is on a read-only filesystem."
+msgstr "'%s' je na súborovom systéme len pre čítanie."
+
+#: ../../WINGs/wfilepanel.c:748 ../../WINGs/wfilepanel.c:780
+#: ../../WINGs/wfilepanel.c:807
+#, c-format
+msgid "Can not delete '%s'."
+msgstr "Nemožno odstrániť '%s'."
+
+#: ../../WINGs/wfilepanel.c:755
+#, c-format
+msgid "Delete directory %s ?"
+msgstr "Odstrániť adresár %s?"
+
+#: ../../WINGs/wfilepanel.c:759
+#, c-format
+msgid "Delete file %s ?"
+msgstr "Odstrániť súbor %s?"
+
+#: ../../WINGs/wfilepanel.c:771
+#, c-format
+msgid "Directory '%s' does not exist."
+msgstr "Adresár '%s' neexistuje."
+
+#: ../../WINGs/wfilepanel.c:774
+#, c-format
+msgid "Directory '%s' is not empty."
+msgstr "Adresár '%s' nie je prázdny."
+
+#: ../../WINGs/wfilepanel.c:777
+#, c-format
+msgid "Directory '%s' is busy."
+msgstr "Adresár '%s' je používaný."
+
+#: ../../WINGs/wfilepanel.c:790
+#, c-format
+msgid "'%s' is a directory."
+msgstr "'%s' je adresár."
+
+#: ../../WINGs/wfilepanel.c:832
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Pri prehliadaní '%s' nastala chyba."
+
+#: ../../WINGs/wfilepanel.c:836
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "'%s' nie je adresár."
+
+#: ../../WINGs/wfilepanel.c:973
+msgid "File does not exist."
+msgstr "Súbor neexistuje."
+
+#: ../../WINGs/wfont.c:324 ../../WINGs/wfont.c:344
+#, c-format
+msgid "could not load font %s."
+msgstr "nemožno načítať font %s."
+
+#: ../../WINGs/wfont.c:375 ../../WINGs/wfont.c:420 ../../WINGs/wfont.c:475
+#: ../../WINGs/wfont.c:1337 ../../WINGs/wfont.c:1398 ../../WINGs/wfont.c:1469
+#, c-format
+msgid ""
+"Conversion to widechar failed (possible invalid multibyte sequence): '%s':"
+"(pos %d)\n"
+msgstr ""
+"Konverzia do widechar zlyhala (možno nesprávna multibyte sekvencia): '%s':"
+"(pos %d)\n"
+
+#. // remove warning later. or maybe not
+#: ../../WINGs/wfont.c:591 ../../WINGs/wfont.c:1568
+#, c-format
+msgid "Invalid font specification: '%s'\n"
+msgstr "Chybná špecifikácia fontu: '%s'\n"
+
+#: ../../WINGs/wfont.c:770 ../../WINGs/wfont.c:780
+#, c-format
+msgid "Invalid size specification '%s' in %s. Using default %d\n"
+msgstr "Chybná špecifikácia veľkosti '%s' v %s. Použije sa implicitná %d\n"
+
+#: ../../WINGs/wfont.c:824
+#, c-format
+msgid "the following character sets are missing in %s:"
+msgstr "nasledujúce sady znakov chýbajú v %s:"
+
+#: ../../WINGs/wfont.c:830
+#, c-format
+msgid ""
+"the string \"%s\" will be used in place of any characters from those sets."
+msgstr "reťazec \"%s\" bude použitý namiesto znakov z týchto sád."
+
+#. is arial a good fallback for multibyte?
+#: ../../WINGs/wfont.c:1232 ../../WINGs/wfont.c:1247
+#, c-format
+msgid "could not load font %s. Trying arial."
+msgstr "nemožno načítať font %s. Skúša sa načítať arial."
+
+#: ../../WINGs/wfont.c:1239
+msgid "could not load antialiased font set. Reverting to standard font sets."
+msgstr "nemožno načítať antialiasovanú sadu fontov. Späť k štandardnej sade fontov."
+
+#: ../../WINGs/wfont.c:1242
+#, c-format
+msgid "could not load FontSet %s. Trying fixed."
+msgstr "nemožno načítať sadu fontov %s. Skúša sa načítať fixed."
+
+#: ../../WINGs/wfont.c:1254
+msgid "could not load antialiased fonts. Reverting to normal fonts."
+msgstr "nemožno zaviesť antialiasovaný font. Návrat k normálnemu fontu."
+
+#: ../../WINGs/wfont.c:1257 ../../WINGs/wfont.c:1268
+#, c-format
+msgid "could not load font %s. Trying fixed."
+msgstr "nemožno načítať font %s. Skúša sa načítať fixed."
+
+#: ../../WINGs/wfont.c:1262
+#, c-format
+msgid "could not load font set %s. Trying fixed."
+msgstr "nemožno načítať font %s. Skúša sa načítať fixed."
+
+#: ../../WINGs/wfont.c:1272
+msgid "could not load fixed font!"
+msgstr "nemožno načítať font fixed!"
+
+#: ../../WINGs/wfont.c:1520
+#, c-format
+msgid "font description %s is too large."
+msgstr "popis fontu %s je príliš veľký."
+
+#: ../../WINGs/wfontpanel.c:235
+msgid "Test!!!"
+msgstr "Skúška!!!"
+
+#: ../../WINGs/wfontpanel.c:241
+msgid "Family"
+msgstr "Rodina"
+
+#: ../../WINGs/wfontpanel.c:252
+msgid "Typeface"
+msgstr "Vzhľad"
+
+#: ../../WINGs/wfontpanel.c:263
+msgid "Size"
+msgstr "Veľkosť"
+
+#: ../../WINGs/wfontpanel.c:282
+msgid "Set"
+msgstr "Sada"
+
+#: ../../WINGs/wfontpanel.c:288
+msgid "Revert"
+msgstr "Obrátiť"
+
+#: ../../WINGs/wfontpanel.c:751
+msgid "Could not retrieve font list"
+msgstr "Nemožno obdržať zoznam fontov"
+
+#: ../../WINGs/wfontpanel.c:765
+#, c-format
+msgid "font name %s is longer than 256, which is invalid."
+msgstr "meno fontu %s je dlhšie ako 256, čo je nesprávne."
+
+#: ../../WINGs/wfontpanel.c:913
+msgid "Roman"
+msgstr "roman"
+
+#: ../../WINGs/wfontpanel.c:916
+msgid "Italic"
+msgstr "kurzíva"
+
+#: ../../WINGs/wfontpanel.c:918
+msgid "Oblique"
+msgstr "šikmé"
+
+#: ../../WINGs/wfontpanel.c:920
+msgid "Rev Italic"
+msgstr "obr. kurzíva"
+
+#: ../../WINGs/wfontpanel.c:922
+msgid "Rev Oblique"
+msgstr "obr. šikmé"
+
+#: ../../WINGs/wfontpanel.c:928
+msgid "Normal"
+msgstr "normálne"
+
+#: ../../WINGs/widgets.c:419
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: nemožno načítať súbor s obrázkami pre widgety: %s"
+
+#: ../../WINGs/widgets.c:772
+msgid ""
+"could not load any fonts. Make sure your font installation and locale "
+"settings are correct."
+msgstr ""
+"nemožno načítať žiadny font. Ubezpečte sa, že inštalácia fontov a miestne "
+"nastavenia sú v poriadku."
+
+#: ../../WINGs/wruler.c:192
+msgid "0   inches"
+msgstr "0    palcov"

bazel/WINGs/po/sr.po

@@ -0,0 +1,806 @@
+# Serbian messages for Window Maker
+# Copyright (C) 1997-2006 Alfredo K. Kojima
+# 		1998-2006 Dan Pascu
+# 		2013-2020 Window Maker Developers Team
+# This file is distributed under the same license as the Window Maker package.
+# Strahinya Radich (Страхиња Радић) <contact@strahinja.org>, 2023.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: WindowMaker 0.96.0\n"
+"Report-Msgid-Bugs-To: wmaker-dev@googlegroups.com\n"
+"POT-Creation-Date: 2023-11-02 19:36+0100\n"
+"PO-Revision-Date: 2023-11-02 19:48+0100\n"
+"Last-Translator: Страхиња Радић <contact@strahinja.org>\n"
+"Language-Team: Serbian <sr@li.org>\n"
+"Language: sr\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
+"X-Generator: poe 1.6.0-1-g10e6dcc\n"
+
+#: ../../WINGs/error.c:106
+msgid "fatal: "
+msgstr "фатално: "
+
+#: ../../WINGs/error.c:112
+msgid "error: "
+msgstr "грешка: "
+
+#: ../../WINGs/error.c:118
+msgid "warning: "
+msgstr "упозорење: "
+
+#: ../../WINGs/findfile.c:59
+#, c-format
+msgid "could not get password entry for UID %i"
+msgstr "не може се добавити унос лозинке за UID %i"
+
+#: ../../WINGs/findfile.c:89
+#, c-format
+msgid "could not get password entry for user %s"
+msgstr "не може се добавити унос лозинке за корисника %s"
+
+#: ../../WINGs/findfile.c:208
+#, c-format
+msgid "could not expand %s"
+msgstr "не може се проширити %s"
+
+#: ../../WINGs/findfile.c:437
+#, c-format
+msgid "Could not open input file \"%s\": %s"
+msgstr "Не може се отворити улазна датотека „%s“: %s"
+
+#: ../../WINGs/findfile.c:453
+#, c-format
+msgid "Could not create target file \"%s\": %s"
+msgstr "Не може се креирати одредишна датотека „%s“: %s"
+
+#: ../../WINGs/findfile.c:461
+msgid "could not allocate memory for the copy buffer"
+msgstr "не може се алоцирати меморија за бафер за копирање"
+
+#: ../../WINGs/findfile.c:478
+#, c-format
+msgid "could not read from file \"%s\": %s"
+msgstr "не може се прочитати датотека „%s“: %s"
+
+#: ../../WINGs/findfile.c:493
+#, c-format
+msgid "could not write data to file \"%s\": %s"
+msgstr "не могу се уписати подаци у датотеку „%s“: %s"
+
+#: ../../WINGs/findfile.c:505
+#, c-format
+msgid "could not set permission 0%03o on file \"%s\": %s"
+msgstr "не може се поставити дозвола 0%03o на датотеци „%s“: %s"
+
+#: ../../WINGs/findfile.c:509
+#, c-format
+msgid "could not close the file \"%s\": %s"
+msgstr "не може се затворити датотека „%s“: %s"
+
+#: ../../WINGs/menuparser.c:110
+#, c-format
+msgid "   included from file \"%s\" at line %d"
+msgstr "   укључена из датотеке „%s“ у реду %d"
+
+#: ../../WINGs/menuparser.c:142
+#, c-format
+msgid "missing #endif to match #%s at line %d"
+msgstr "недостаје #endif који би одговарао #%s у реду %d"
+
+#: ../../WINGs/menuparser.c:200
+msgid "multiple SHORTCUT definition not valid"
+msgstr "вишеструка дефиниција SHORTCUT није исправна"
+
+#: ../../WINGs/menuparser.c:253
+msgid "premature end of file while expecting a new line after '\\'"
+msgstr "прерани крај датотеке док се очекивао нови ред после „\\“"
+
+#: ../../WINGs/menuparser.c:279
+#, c-format
+msgid "reached end of file while searching '*/' for comment started at line %d"
+msgstr "достигнут крај датотеке приликом тражења „*/“ за коментар започет у реду %d"
+
+#: ../../WINGs/menuparser.c:344
+msgid "missing closing double-quote before end-of-line"
+msgstr "недостаје завршни наводник пре краја реда"
+
+#: ../../WINGs/menuparser.c:362
+msgid "missing closing simple-quote before end-of-line"
+msgstr "недостаје завршни апостроф пре краја реда"
+
+#: ../../WINGs/menuparser.c:380
+msgid "too many nested macro expansions, breaking loop"
+msgstr "превише угњеждених проширења макроа, прекида се петља"
+
+#: ../../WINGs/menuparser.c:439
+#, c-format
+msgid "unknown directive '#%s'"
+msgstr "непозната директива „#%s“"
+
+#: ../../WINGs/menuparser.c:444
+#, c-format
+msgid "extra text after '#' command is ignored: \"%.16s...\""
+msgstr "сувишни текст после наредбе „#“ је игнорисан: „%.16s...“"
+
+#: ../../WINGs/menuparser.c:459
+msgid "no file name found for #include"
+msgstr "назив датотеке у #include-у није пронађен"
+
+#: ../../WINGs/menuparser.c:471
+msgid "file name must be enclosed in brackets or double-quotes for #define"
+msgstr "назив датотеке у #define-у мора бити окружен угластим заградама или наводницима"
+
+#: ../../WINGs/menuparser.c:485
+#, c-format
+msgid "missing closing '%c' in filename specification"
+msgstr "недостаје завршно „%c“ у задавању назива датотеке"
+
+#: ../../WINGs/menuparser.c:503
+msgid "too many nested #include's"
+msgstr "превише угњеждених #include-ова"
+
+#: ../../WINGs/menuparser.c:568
+#, c-format
+msgid "could not find file \"%s\" for #include"
+msgstr "не може се наћи датотека „%s“ у #include-у"
+
+#: ../../WINGs/menuparser.c:589
+#, c-format
+msgid "missing macro name argument to #%s"
+msgstr "недостаје аргумент #%s - назив макроа"
+
+#: ../../WINGs/menuparser.c:600
+msgid "too many nested #if sequences"
+msgstr "превише угњеждених секвенци #if"
+
+#: ../../WINGs/menuparser.c:626 ../../WINGs/menuparser.c:643
+#, c-format
+msgid "found #%s but has no matching #if"
+msgstr "пронађено #%s, али без одговарајућег #if"
+
+#: ../../WINGs/menuparser_macros.c:166
+msgid "no macro name found for #define"
+msgstr "назив макроа за #define није пронађен"
+
+#: ../../WINGs/menuparser_macros.c:188
+#, c-format
+msgid "premature end of file while reading arg-list for macro \"%s\""
+msgstr "прерани крај датотеке приликом читања листе аргумената за макро „%s“"
+
+#: ../../WINGs/menuparser_macros.c:195
+#, c-format
+msgid "too many parameters for macro \"%s\" definition"
+msgstr "превише параметара за дефиницију макроа „%s“"
+
+#: ../../WINGs/menuparser_macros.c:210
+#, c-format
+msgid "invalid character '%c' in arg-list for macro \"%s\" while expecting parameter name"
+msgstr "неисправни знак „%c“ у листи аргумената за макро „%s“ док се очекивао назив параметра"
+
+#: ../../WINGs/menuparser_macros.c:221
+#, c-format
+msgid "invalid character '%c' in arg-list for macro \"%s\" while expecting ',' or ')'"
+msgstr "неисправни знак „%c“ у листи аргумената за макро „%s“ док се очекивало „,“ или „)“"
+
+#: ../../WINGs/menuparser_macros.c:254
+#, c-format
+msgid "macro \"%s\" already defined, ignoring redefinition"
+msgstr "макро „%s“ је већ дефинисан, игнорише се поновна дефиниција"
+
+#: ../../WINGs/menuparser_macros.c:348
+#, c-format
+msgid "more content than supported for the macro \"%s\""
+msgstr "више садржаја него што је подржано за макро „%s“"
+
+#: ../../WINGs/menuparser_macros.c:459
+#, c-format
+msgid "expansion for macro \"%s\" too big, line truncated"
+msgstr "проширење макроа „%s“ је превелико, ред је исечен"
+
+#: ../../WINGs/menuparser_macros.c:471
+#, c-format
+msgid "macro \"%s\" needs parenthesis for arguments"
+msgstr "макроу „%s“ су потребне заграде за аргументе"
+
+#: ../../WINGs/menuparser_macros.c:502
+msgid "missing closing quote or double-quote before end-of-line"
+msgstr "недостаје завршни наводник или апостроф пре краја реда"
+
+#: ../../WINGs/menuparser_macros.c:525
+#, c-format
+msgid "too many arguments for macro \"%s\", expected only %d"
+msgstr "превише аргумената за макро „%s“, очекује се само %d"
+
+#: ../../WINGs/menuparser_macros.c:534
+#, c-format
+msgid "premature end of line while searching for arguments to macro \"%s\""
+msgstr "прерани крај реда приликом тражења аргумената за макро „%s“"
+
+#: ../../WINGs/menuparser_macros.c:540
+#, c-format
+msgid "not enough arguments for macro \"%s\", expected %d but got only %d"
+msgstr "недовољно аргумената за макро „%s“, очекује се %d, али само постоји %d"
+
+#: ../../WINGs/menuparser_macros.c:545
+#, c-format
+msgid "too much data in parameter list of macro \"%s\", truncated"
+msgstr "превише података у листи параметара макроа „%s“, исечено"
+
+#: ../../WINGs/menuparser_macros.c:565
+#, c-format
+msgid "size of value for macro '%s' is too big, truncated"
+msgstr "величина вредности макроа „%s“ је превелика, исечено"
+
+#: ../../WINGs/menuparser_macros.c:646 ../../WINGs/menuparser_macros.c:672
+#, c-format
+msgid "could not determine %s"
+msgstr "не може се одредити %s"
+
+#: ../../WINGs/proplist.c:78
+#, c-format
+msgid "syntax error in %s %s, line %i: %s"
+msgstr "синтаксна грешка у %s %s, ред %i: %s"
+
+#: ../../WINGs/proplist.c:134
+msgid "Only string or data is supported for a proplist dictionary key"
+msgstr "Само ниска или подаци су подржани у proplist речничком кључу"
+
+#: ../../WINGs/proplist.c:167 ../../WINGs/proplist.c:217
+#: ../../WINGs/proplist.c:382 ../../WINGs/proplist.c:458
+#: ../../WINGs/proplist.c:1048 ../../WINGs/proplist.c:1098
+#: ../../WINGs/proplist.c:1246 ../../WINGs/proplist.c:1326
+#: ../../WINGs/proplist.c:1431 ../../WINGs/proplist.c:1475
+msgid "Used proplist functions on non-WMPropLists objects"
+msgstr "Користе се proplist функције над не-WMPropLists објектима"
+
+#: ../../WINGs/proplist.c:635
+msgid "unterminated PropList string"
+msgstr "незатворена PropList ниска"
+
+#: ../../WINGs/proplist.c:673
+msgid "unterminated PropList data"
+msgstr "незатворен PropList податак"
+
+#: ../../WINGs/proplist.c:681
+msgid "unterminated PropList data (missing hexdigit)"
+msgstr "незатворен PropList податак (недостаје хекс-цифра)"
+
+#: ../../WINGs/proplist.c:693 ../../WINGs/proplist.c:698
+msgid "non hexdigit character in PropList data"
+msgstr "знак који није хекс-цифра у PropList подацима"
+
+#: ../../WINGs/proplist.c:730
+msgid "unterminated PropList array"
+msgstr "незатворен PropList низ"
+
+#: ../../WINGs/proplist.c:738
+msgid "missing or unterminated PropList array"
+msgstr "недостајући или незатворени PropList низ"
+
+#: ../../WINGs/proplist.c:748
+msgid "could not get PropList array element"
+msgstr "не може се добавити елемент PropList низа"
+
+#: ../../WINGs/proplist.c:775
+msgid "unterminated PropList dictionary"
+msgstr "незатворени PropList речник"
+
+#: ../../WINGs/proplist.c:792
+msgid "missing PropList dictionary key"
+msgstr "недостајући кључ PropList речника"
+
+#: ../../WINGs/proplist.c:794
+msgid "missing PropList dictionary entry key or unterminated dictionary"
+msgstr "недостаје кључ PropList речничке ставке или је речник незатворен"
+
+#: ../../WINGs/proplist.c:802
+msgid "error parsing PropList dictionary key"
+msgstr "грешка приликом рашчлањивања кључа PropList речника"
+
+#: ../../WINGs/proplist.c:810
+msgid "missing = in PropList dictionary entry"
+msgstr "недостаје = у ставци PropList речника"
+
+#: ../../WINGs/proplist.c:818
+msgid "error parsing PropList dictionary entry value"
+msgstr "грешка приликом рашчлањивања вредности PropList речничког уноса"
+
+#: ../../WINGs/proplist.c:826
+msgid "missing ; in PropList dictionary entry"
+msgstr "недостаје ; у речничком уносу PropList"
+
+#: ../../WINGs/proplist.c:885
+msgid "was expecting a string, data, array or dictionary. If it's a string, try enclosing it with \"."
+msgstr "очекује се ниска, податак, низ или речник. Ако је у питању ниска, пробајте да је окружите са \"."
+
+#: ../../WINGs/proplist.c:888
+msgid "Comments are not allowed inside WindowMaker owned domain files."
+msgstr "Коментари нису дозвољени унутар датотека домена WindowMaker-а."
+
+#: ../../WINGs/proplist.c:1495 ../../WINGs/proplist.c:1560
+#: ../../WINGs/proplist.c:1624
+msgid "extra data after end of property list"
+msgstr "вишак података после листе особина"
+
+#: ../../WINGs/proplist.c:1535
+#, c-format
+msgid "could not get size for file '%s'"
+msgstr "не може се одредити величина датотеке „%s“"
+
+#: ../../WINGs/proplist.c:1543
+#, c-format
+msgid "error reading from file '%s'"
+msgstr "грешка приликом читања датотеке „%s“"
+
+#: ../../WINGs/proplist.c:1590
+#, c-format
+msgid "%s:could not open menu file"
+msgstr "%s:не може се отворити датотека менија"
+
+#: ../../WINGs/proplist.c:1672
+#, c-format
+msgid "mkstemp (%s) failed"
+msgstr "mkstemp (%s) није успео"
+
+#: ../../WINGs/proplist.c:1682
+#, c-format
+msgid "mktemp (%s) failed"
+msgstr "mktemp (%s) није успео"
+
+#: ../../WINGs/proplist.c:1689
+#, c-format
+msgid "open (%s) failed"
+msgstr "open (%s) није успео"
+
+#: ../../WINGs/proplist.c:1696
+#, c-format
+msgid "writing to file: %s failed"
+msgstr "уписивање у датотеку: %s није успело"
+
+#: ../../WINGs/proplist.c:1706
+#, c-format
+msgid "fclose (%s) failed"
+msgstr "fclose (%s) није успео"
+
+#: ../../WINGs/proplist.c:1714
+#, c-format
+msgid "rename ('%s' to '%s') failed"
+msgstr "rename („%s“ у „%s“) није успео"
+
+#: ../../WINGs/proplist.c:1785
+#, c-format
+msgid "Could not create component %s"
+msgstr "Не може се креирати компонента %s"
+
+#: ../../WINGs/userdefaults.c:68
+msgid "variable WMAKER_USER_ROOT defined with invalid path, not used"
+msgstr "променљива WMAKER_USER_ROOT је задата са неисправном путањом, не користи се"
+
+#. something happened with the file. just overwrite it
+#: ../../WINGs/userdefaults.c:208 ../../WINGs/userdefaults.c:223
+#, c-format
+msgid "cannot read domain from file '%s' when syncing"
+msgstr "не може се учитати домен из датотеке „%s“ приликом синхронизовања"
+
+#: ../../WINGs/dragcommon.c:60
+#, c-format
+msgid "unknown XDND action %s"
+msgstr "непозната XDND акција %s"
+
+#: ../../WINGs/dragcommon.c:142
+#, c-format
+msgid "target %lu for XDND message no longer exists"
+msgstr "одредиште %lu XDND поруке више не постоји"
+
+#: ../../WINGs/dragcommon.c:220
+#, c-format
+msgid "unsupported version %i for XDND enter message"
+msgstr "неподржана верзија %i XDND улазне поруке"
+
+#: ../../WINGs/dragsource.c:163
+msgid "XDND selection lost during drag operation..."
+msgstr "XDND избор је изгубљен приликом операције превлачења..."
+
+#: ../../WINGs/dragsource.c:758
+msgid "could not get XDND version for target of drop"
+msgstr "не може се одредити верзија XDND-а за одредиште превлачења"
+
+#: ../../WINGs/dragsource.c:774
+msgid "could not get ownership of XDND selection"
+msgstr "не може се одредити власништво над XDND избором"
+
+#: ../../WINGs/dragsource.c:1070
+msgid "delay for drag destination response expired"
+msgstr "пауза за одговор одредишта превлачења је истекла"
+
+#: ../../WINGs/wcolor.c:204 ../../WINGs/wcolor.c:214 ../../WINGs/wcolor.c:250
+#: ../../WINGs/wcolor.c:288
+#, c-format
+msgid "could not allocate %s color"
+msgstr "не може се алоцирати боја %s"
+
+#: ../../WINGs/wcolor.c:204
+msgid "white"
+msgstr "бела"
+
+#: ../../WINGs/wcolor.c:214
+msgid "black"
+msgstr "црна"
+
+#: ../../WINGs/wcolor.c:250
+msgid "gray"
+msgstr "сива"
+
+#: ../../WINGs/wcolor.c:288
+msgid "dark gray"
+msgstr "тамно сива"
+
+#: ../../WINGs/wcolorpanel.c:390
+msgid "Colors"
+msgstr "Боје"
+
+#: ../../WINGs/wcolorpanel.c:565 ../../WINGs/wcolorpanel.c:2716
+msgid "Brightness"
+msgstr "Светлина"
+
+#: ../../WINGs/wcolorpanel.c:567 ../../WINGs/wcolorpanel.c:641
+#: ../../WINGs/wcolorpanel.c:672 ../../WINGs/wcolorpanel.c:703
+#: ../../WINGs/wcolorpanel.c:778 ../../WINGs/wcolorpanel.c:809
+#: ../../WINGs/wcolorpanel.c:841 ../../WINGs/wcolorpanel.c:874
+#: ../../WINGs/wcolorpanel.c:2010 ../../WINGs/wcolorpanel.c:2718
+#: ../../WINGs/wcolorpanel.c:2752 ../../WINGs/wcolorpanel.c:2786
+msgid "Color Panel: Could not allocate memory"
+msgstr "Панел за боје: Неуспешно алоцирање меморије"
+
+#: ../../WINGs/wcolorpanel.c:639
+msgid "Red"
+msgstr "Црвена"
+
+#: ../../WINGs/wcolorpanel.c:670
+msgid "Green"
+msgstr "Зелена"
+
+#: ../../WINGs/wcolorpanel.c:701
+msgid "Blue"
+msgstr "Плава"
+
+#: ../../WINGs/wcolorpanel.c:715
+msgid "Decimal"
+msgstr "Децимално"
+
+#: ../../WINGs/wcolorpanel.c:723
+msgid "Hexadecimal"
+msgstr "Хексадекадно"
+
+#: ../../WINGs/wcolorpanel.c:776
+msgid "Cyan"
+msgstr "Цијан"
+
+#: ../../WINGs/wcolorpanel.c:807
+msgid "Magenta"
+msgstr "Магента"
+
+#: ../../WINGs/wcolorpanel.c:839
+msgid "Yellow"
+msgstr "Жута"
+
+#: ../../WINGs/wcolorpanel.c:872
+msgid "Black"
+msgstr "Црна"
+
+#: ../../WINGs/wcolorpanel.c:947
+msgid "Spectrum"
+msgstr "Спектар"
+
+#: ../../WINGs/wcolorpanel.c:973
+msgid "Palette"
+msgstr "Палета"
+
+#: ../../WINGs/wcolorpanel.c:978
+msgid "New from File..."
+msgstr "Нова из датотеке..."
+
+#: ../../WINGs/wcolorpanel.c:979 ../../WINGs/wcolorpanel.c:1024
+#: ../../WINGs/wcolorpanel.c:1039
+msgid "Rename..."
+msgstr "Преименуј..."
+
+#: ../../WINGs/wcolorpanel.c:980 ../../WINGs/wcolorpanel.c:1025
+#: ../../WINGs/wcolorpanel.c:1040 ../../WINGs/wcolorpanel.c:3176
+msgid "Remove"
+msgstr "Уклони"
+
+#: ../../WINGs/wcolorpanel.c:981
+msgid "Copy"
+msgstr "Копирај"
+
+#: ../../WINGs/wcolorpanel.c:982
+msgid "New from Clipboard"
+msgstr "Нова из клипборда"
+
+#: ../../WINGs/wcolorpanel.c:1001
+msgid "X11-Colors"
+msgstr "X11 боје"
+
+#: ../../WINGs/wcolorpanel.c:1018
+msgid "Color"
+msgstr "Боја"
+
+#: ../../WINGs/wcolorpanel.c:1023
+msgid "Add..."
+msgstr "Додај..."
+
+#: ../../WINGs/wcolorpanel.c:1033
+msgid "List"
+msgstr "Листа"
+
+#: ../../WINGs/wcolorpanel.c:1038
+msgid "New..."
+msgstr "Нова..."
+
+#: ../../WINGs/wcolorpanel.c:1165
+#, c-format
+msgid "Color Panel: Could not create directory %s needed to store configurations"
+msgstr "Панел за боје: Не може се креирати директоријум %s неопходан за чување подешавања"
+
+#. Delete the file, it doesn't belong here
+#: ../../WINGs/wcolorpanel.c:1171 ../../WINGs/wcolorpanel.c:3069
+#: ../../WINGs/wcolorpanel.c:3073
+msgid "File Error"
+msgstr "Грешка датотеке"
+
+#: ../../WINGs/wcolorpanel.c:1172
+msgid "Could not create ColorPanel configuration directory"
+msgstr "Не може се креирати директоријум са подешавањима ColorPanel"
+
+#: ../../WINGs/wcolorpanel.c:1173 ../../WINGs/wcolorpanel.c:3070
+#: ../../WINGs/wcolorpanel.c:3075 ../../WINGs/wcolorpanel.c:3100
+#: ../../WINGs/wfilepanel.c:227 ../../WINGs/wfilepanel.c:596
+#: ../../WINGs/wfilepanel.c:611 ../../WINGs/wfilepanel.c:715
+#: ../../WINGs/wfilepanel.c:883 ../../WINGs/wfontpanel.c:532
+msgid "OK"
+msgstr "ОК"
+
+#: ../../WINGs/wcolorpanel.c:1178
+msgid "Color Panel: Could not find file"
+msgstr "Панел за боје: Не може се пронаћи датотека"
+
+#: ../../WINGs/wcolorpanel.c:1374 ../../WINGs/wcolorpanel.c:1435
+#: ../../WINGs/wcolorpanel.c:1495
+msgid "Color Panel: X failed request"
+msgstr "Панел за боје: Неуспешан захтев X-а"
+
+#: ../../WINGs/wcolorpanel.c:2750
+msgid "Saturation"
+msgstr "Засићење"
+
+#: ../../WINGs/wcolorpanel.c:2784
+msgid "Hue"
+msgstr "Нијанса"
+
+#: ../../WINGs/wcolorpanel.c:3008
+msgid "Open Palette"
+msgstr "Отвори палету"
+
+#: ../../WINGs/wcolorpanel.c:3070
+msgid "Invalid file format !"
+msgstr "Неисправан формат датотеке !"
+
+#: ../../WINGs/wcolorpanel.c:3072
+#, c-format
+msgid "can't remove file %s"
+msgstr "не може се уклонити датотека %s"
+
+#: ../../WINGs/wcolorpanel.c:3074
+msgid "Couldn't remove file from Configuration Directory !"
+msgstr "Не може се уклонити датотека из директоријума са подешавањима !"
+
+#: ../../WINGs/wcolorpanel.c:3099
+msgid "Rename"
+msgstr "Преименовање"
+
+#: ../../WINGs/wcolorpanel.c:3099
+msgid "Rename palette to:"
+msgstr "Преименуј палету у:"
+
+#: ../../WINGs/wcolorpanel.c:3100 ../../WINGs/wfilepanel.c:236
+#: ../../WINGs/wfilepanel.c:611 ../../WINGs/wfilepanel.c:715
+msgid "Cancel"
+msgstr "Поништи"
+
+#. Careful, this palette exists already
+#: ../../WINGs/wcolorpanel.c:3116 ../../WINGs/wfilepanel.c:715
+msgid "Warning"
+msgstr "Упозорење"
+
+#: ../../WINGs/wcolorpanel.c:3117
+msgid "Palette already exists !\n\nOverwrite ?"
+msgstr "Палета већ постоји !\n\nПреписати ?"
+
+#: ../../WINGs/wcolorpanel.c:3117 ../../WINGs/wcolorpanel.c:3176
+msgid "No"
+msgstr "Не"
+
+#: ../../WINGs/wcolorpanel.c:3117 ../../WINGs/wcolorpanel.c:3176
+msgid "Yes"
+msgstr "Да"
+
+#: ../../WINGs/wcolorpanel.c:3148
+#, c-format
+msgid "Couldn't rename palette %s to %s"
+msgstr "Палета %s се не може преименовати у %s"
+
+#: ../../WINGs/wcolorpanel.c:3171
+msgid "This will permanently remove the palette "
+msgstr "Ово ће трајно уклонити палету "
+
+#: ../../WINGs/wcolorpanel.c:3173
+msgid ".\n\nAre you sure you want to remove this palette ?"
+msgstr ".\n\nДа ли сте сигурни да желите да уклоните палету ?"
+
+#: ../../WINGs/wcolorpanel.c:3195
+#, c-format
+msgid "Couldn't remove palette %s"
+msgstr "Не може се уклонити палета %s"
+
+#: ../../WINGs/wcolorpanel.c:3498
+msgid "Color Panel: Color unspecified"
+msgstr "Панел за боју: Боја није задата"
+
+#: ../../WINGs/wfilepanel.c:216
+msgid "Name:"
+msgstr "Назив:"
+
+#: ../../WINGs/wfilepanel.c:306 ../../WINGs/wfilepanel.c:364
+msgid "Open"
+msgstr "Отвори"
+
+#: ../../WINGs/wfilepanel.c:322 ../../WINGs/wfilepanel.c:370
+msgid "Save"
+msgstr "Сачувај"
+
+#: ../../WINGs/wfilepanel.c:506
+#, c-format
+msgid "WINGs: could not open directory %s\n"
+msgstr "WINGs: не може се отворити директоријум %s\n"
+
+#: ../../WINGs/wfilepanel.c:526
+#, c-format
+msgid "WINGs: could not stat %s\n"
+msgstr "WINGs: не може се stat-овати %s\n"
+
+#: ../../WINGs/wfilepanel.c:596 ../../WINGs/wfilepanel.c:883
+#: ../../WINGs/wfontpanel.c:531
+msgid "Error"
+msgstr "Грешка"
+
+#: ../../WINGs/wfilepanel.c:610
+msgid "Create Directory"
+msgstr "Креирање директоријума"
+
+#: ../../WINGs/wfilepanel.c:611
+msgid "Enter directory name"
+msgstr "Унесите назив директоријума"
+
+#: ../../WINGs/wfilepanel.c:639
+#, c-format
+msgid "Can not create %s: %s"
+msgstr "Не може се креирати %s: %s"
+
+#: ../../WINGs/wfilepanel.c:705
+#, c-format
+msgid "Can not find %s: %s"
+msgstr "Не може се наћи %s: %s"
+
+#: ../../WINGs/wfilepanel.c:711
+#, c-format
+msgid "Delete %s %s?"
+msgstr "Обрисати %s %s?"
+
+#: ../../WINGs/wfilepanel.c:712
+msgid "directory"
+msgstr "директоријум"
+
+#: ../../WINGs/wfilepanel.c:712
+msgid "file"
+msgstr "датотеку"
+
+#: ../../WINGs/wfilepanel.c:719
+#, c-format
+msgid "Removing %s failed: %s"
+msgstr "Уклањање %s није успело: %s"
+
+#: ../../WINGs/wfilepanel.c:751
+#, c-format
+msgid "An error occurred browsing '%s'."
+msgstr "Догодила се грешка приликом прегледања „%s“."
+
+#: ../../WINGs/wfilepanel.c:754
+#, c-format
+msgid "'%s' is not a directory."
+msgstr "„%s“ није директоријум."
+
+#: ../../WINGs/wfilepanel.c:883
+msgid "File does not exist."
+msgstr "Датотека не постоји."
+
+#: ../../WINGs/wfont.c:43
+#, c-format
+msgid "invalid font: %s. Trying '%s'"
+msgstr "неисправан фонт: %s. Проба се „%s“"
+
+#: ../../WINGs/wfont.c:270 ../../WINGs/wfont.c:288
+#, c-format
+msgid "could not load font: %s."
+msgstr "не може се учитати фонт: %s."
+
+#. WMSetWidgetBackgroundColor(panel->win, WMWhiteColor(scr));
+#: ../../WINGs/wfontpanel.c:184
+msgid "Font Panel"
+msgstr "Панел за фонт"
+
+#: ../../WINGs/wfontpanel.c:220
+msgid "The quick brown fox jumps over the lazy dog"
+msgstr "Одбациће кавгаџија плаштом чађ у жељезни фењер"
+
+#: ../../WINGs/wfontpanel.c:226
+msgid "Family"
+msgstr "Фамилија"
+
+#: ../../WINGs/wfontpanel.c:237
+msgid "Typeface"
+msgstr "Словни лик"
+
+#: ../../WINGs/wfontpanel.c:248
+msgid "Size"
+msgstr "Величина"
+
+#: ../../WINGs/wfontpanel.c:267
+msgid "Set"
+msgstr "Постави"
+
+#: ../../WINGs/wfontpanel.c:273
+msgid "Revert"
+msgstr "Врати"
+
+#: ../../WINGs/wfontpanel.c:532
+msgid "Could not init font config library\n"
+msgstr "Не може се иницијализовати библиотека font config\n"
+
+#: ../../WINGs/widgets.c:447
+#, c-format
+msgid "WINGs: could not load widget images file: %s"
+msgstr "WINGs: не може се учитати датотека са сликама виџета: %s"
+
+#: ../../WINGs/widgets.c:543
+#, c-format
+msgid "WINGs: could not open display %s"
+msgstr "WINGs: не може се отворити приказ %s"
+
+#: ../../WINGs/widgets.c:772
+msgid "could not load any fonts. Make sure your font installation and locale settings are correct."
+msgstr "не може се учитати ниједан фонт. Проверите да ли су фонтови исправно инсталирани и да али су подешавања језика исправна."
+
+#: ../../WINGs/winputmethod.c:65
+msgid "could not add destroy callback for XIM input method"
+msgstr "не може се додати destroy callback за XIM метод уноса"
+
+#: ../../WINGs/wruler.c:175
+msgid "0   inches"
+msgstr "0   инча"
+
+#: ../../WINGs/wtextfield.c:494
+msgid "only left alignment is supported in textfields"
+msgstr "у текстуалним пољима је подржано само лево уравнање"
+
+#: ../../WINGs/wwindow.c:160
+msgid "window title conversion error... using STRING encoding"
+msgstr "грешка приликом конверзије наслова прозора... користи се STRING кодирање"
+
+#: ../../WINGs/wwindow.c:181
+msgid "icon title conversion error... using STRING encoding"
+msgstr "грешка приликом конверзије наслова иконе... користи се STRING кодирање"

bazel/WINGs/rgb.h

@@ -0,0 +1,771 @@
+
+/* Automatically generated file. Do NOT edit. Regenerate it using make-rgb */
+
+#ifndef RGB_H_
+#define RGB_H_
+
+#include "wrlib/wraster.h"
+
+typedef struct RGBColor {
+    RColor color;
+    char *name;
+} RGBColor;
+
+RGBColor rgbColors[] = {
+    {{255, 250, 250, 0}, "snow"},
+    {{248, 248, 255, 0}, "ghost"},
+    {{248, 248, 255, 0}, "GhostWhite"},
+    {{245, 245, 245, 0}, "white"},
+    {{245, 245, 245, 0}, "WhiteSmoke"},
+    {{220, 220, 220, 0}, "gainsboro"},
+    {{255, 250, 240, 0}, "floral"},
+    {{255, 250, 240, 0}, "FloralWhite"},
+    {{253, 245, 230, 0}, "old"},
+    {{253, 245, 230, 0}, "OldLace"},
+    {{250, 240, 230, 0}, "linen"},
+    {{250, 235, 215, 0}, "antique"},
+    {{250, 235, 215, 0}, "AntiqueWhite"},
+    {{255, 239, 213, 0}, "papaya"},
+    {{255, 239, 213, 0}, "PapayaWhip"},
+    {{255, 235, 205, 0}, "blanched"},
+    {{255, 235, 205, 0}, "BlanchedAlmond"},
+    {{255, 228, 196, 0}, "bisque"},
+    {{255, 218, 185, 0}, "peach"},
+    {{255, 218, 185, 0}, "PeachPuff"},
+    {{255, 222, 173, 0}, "navajo"},
+    {{255, 222, 173, 0}, "NavajoWhite"},
+    {{255, 228, 181, 0}, "moccasin"},
+    {{255, 248, 220, 0}, "cornsilk"},
+    {{255, 255, 240, 0}, "ivory"},
+    {{255, 250, 205, 0}, "lemon"},
+    {{255, 250, 205, 0}, "LemonChiffon"},
+    {{255, 245, 238, 0}, "seashell"},
+    {{240, 255, 240, 0}, "honeydew"},
+    {{245, 255, 250, 0}, "mint"},
+    {{245, 255, 250, 0}, "MintCream"},
+    {{240, 255, 255, 0}, "azure"},
+    {{240, 248, 255, 0}, "alice"},
+    {{240, 248, 255, 0}, "AliceBlue"},
+    {{230, 230, 250, 0}, "lavender"},
+    {{255, 240, 245, 0}, "lavender"},
+    {{255, 240, 245, 0}, "LavenderBlush"},
+    {{255, 228, 225, 0}, "misty"},
+    {{255, 228, 225, 0}, "MistyRose"},
+    {{255, 255, 255, 0}, "white"},
+    {{  0,   0,   0, 0}, "black"},
+    {{ 47,  79,  79, 0}, "dark"},
+    {{ 47,  79,  79, 0}, "DarkSlateGray"},
+    {{ 47,  79,  79, 0}, "dark"},
+    {{ 47,  79,  79, 0}, "DarkSlateGrey"},
+    {{105, 105, 105, 0}, "dim"},
+    {{105, 105, 105, 0}, "DimGray"},
+    {{105, 105, 105, 0}, "dim"},
+    {{105, 105, 105, 0}, "DimGrey"},
+    {{112, 128, 144, 0}, "slate"},
+    {{112, 128, 144, 0}, "SlateGray"},
+    {{112, 128, 144, 0}, "slate"},
+    {{112, 128, 144, 0}, "SlateGrey"},
+    {{119, 136, 153, 0}, "light"},
+    {{119, 136, 153, 0}, "LightSlateGray"},
+    {{119, 136, 153, 0}, "light"},
+    {{119, 136, 153, 0}, "LightSlateGrey"},
+    {{190, 190, 190, 0}, "gray"},
+    {{190, 190, 190, 0}, "grey"},
+    {{211, 211, 211, 0}, "light"},
+    {{211, 211, 211, 0}, "LightGrey"},
+    {{211, 211, 211, 0}, "light"},
+    {{211, 211, 211, 0}, "LightGray"},
+    {{ 25,  25, 112, 0}, "midnight"},
+    {{ 25,  25, 112, 0}, "MidnightBlue"},
+    {{  0,   0, 128, 0}, "navy"},
+    {{  0,   0, 128, 0}, "navy"},
+    {{  0,   0, 128, 0}, "NavyBlue"},
+    {{100, 149, 237, 0}, "cornflower"},
+    {{100, 149, 237, 0}, "CornflowerBlue"},
+    {{ 72,  61, 139, 0}, "dark"},
+    {{ 72,  61, 139, 0}, "DarkSlateBlue"},
+    {{106,  90, 205, 0}, "slate"},
+    {{106,  90, 205, 0}, "SlateBlue"},
+    {{123, 104, 238, 0}, "medium"},
+    {{123, 104, 238, 0}, "MediumSlateBlue"},
+    {{132, 112, 255, 0}, "light"},
+    {{132, 112, 255, 0}, "LightSlateBlue"},
+    {{  0,   0, 205, 0}, "medium"},
+    {{  0,   0, 205, 0}, "MediumBlue"},
+    {{ 65, 105, 225, 0}, "royal"},
+    {{ 65, 105, 225, 0}, "RoyalBlue"},
+    {{  0,   0, 255, 0}, "blue"},
+    {{ 30, 144, 255, 0}, "dodger"},
+    {{ 30, 144, 255, 0}, "DodgerBlue"},
+    {{  0, 191, 255, 0}, "deep"},
+    {{  0, 191, 255, 0}, "DeepSkyBlue"},
+    {{135, 206, 235, 0}, "sky"},
+    {{135, 206, 235, 0}, "SkyBlue"},
+    {{135, 206, 250, 0}, "light"},
+    {{135, 206, 250, 0}, "LightSkyBlue"},
+    {{ 70, 130, 180, 0}, "steel"},
+    {{ 70, 130, 180, 0}, "SteelBlue"},
+    {{176, 196, 222, 0}, "light"},
+    {{176, 196, 222, 0}, "LightSteelBlue"},
+    {{173, 216, 230, 0}, "light"},
+    {{173, 216, 230, 0}, "LightBlue"},
+    {{176, 224, 230, 0}, "powder"},
+    {{176, 224, 230, 0}, "PowderBlue"},
+    {{175, 238, 238, 0}, "pale"},
+    {{175, 238, 238, 0}, "PaleTurquoise"},
+    {{  0, 206, 209, 0}, "dark"},
+    {{  0, 206, 209, 0}, "DarkTurquoise"},
+    {{ 72, 209, 204, 0}, "medium"},
+    {{ 72, 209, 204, 0}, "MediumTurquoise"},
+    {{ 64, 224, 208, 0}, "turquoise"},
+    {{  0, 255, 255, 0}, "cyan"},
+    {{224, 255, 255, 0}, "light"},
+    {{224, 255, 255, 0}, "LightCyan"},
+    {{ 95, 158, 160, 0}, "cadet"},
+    {{ 95, 158, 160, 0}, "CadetBlue"},
+    {{102, 205, 170, 0}, "medium"},
+    {{102, 205, 170, 0}, "MediumAquamarine"},
+    {{127, 255, 212, 0}, "aquamarine"},
+    {{  0, 100,   0, 0}, "dark"},
+    {{  0, 100,   0, 0}, "DarkGreen"},
+    {{ 85, 107,  47, 0}, "dark"},
+    {{ 85, 107,  47, 0}, "DarkOliveGreen"},
+    {{143, 188, 143, 0}, "dark"},
+    {{143, 188, 143, 0}, "DarkSeaGreen"},
+    {{ 46, 139,  87, 0}, "sea"},
+    {{ 46, 139,  87, 0}, "SeaGreen"},
+    {{ 60, 179, 113, 0}, "medium"},
+    {{ 60, 179, 113, 0}, "MediumSeaGreen"},
+    {{ 32, 178, 170, 0}, "light"},
+    {{ 32, 178, 170, 0}, "LightSeaGreen"},
+    {{152, 251, 152, 0}, "pale"},
+    {{152, 251, 152, 0}, "PaleGreen"},
+    {{  0, 255, 127, 0}, "spring"},
+    {{  0, 255, 127, 0}, "SpringGreen"},
+    {{124, 252,   0, 0}, "lawn"},
+    {{124, 252,   0, 0}, "LawnGreen"},
+    {{  0, 255,   0, 0}, "green"},
+    {{127, 255,   0, 0}, "chartreuse"},
+    {{  0, 250, 154, 0}, "medium"},
+    {{  0, 250, 154, 0}, "MediumSpringGreen"},
+    {{173, 255,  47, 0}, "green"},
+    {{173, 255,  47, 0}, "GreenYellow"},
+    {{ 50, 205,  50, 0}, "lime"},
+    {{ 50, 205,  50, 0}, "LimeGreen"},
+    {{154, 205,  50, 0}, "yellow"},
+    {{154, 205,  50, 0}, "YellowGreen"},
+    {{ 34, 139,  34, 0}, "forest"},
+    {{ 34, 139,  34, 0}, "ForestGreen"},
+    {{107, 142,  35, 0}, "olive"},
+    {{107, 142,  35, 0}, "OliveDrab"},
+    {{189, 183, 107, 0}, "dark"},
+    {{189, 183, 107, 0}, "DarkKhaki"},
+    {{240, 230, 140, 0}, "khaki"},
+    {{238, 232, 170, 0}, "pale"},
+    {{238, 232, 170, 0}, "PaleGoldenrod"},
+    {{250, 250, 210, 0}, "light"},
+    {{250, 250, 210, 0}, "LightGoldenrodYellow"},
+    {{255, 255, 224, 0}, "light"},
+    {{255, 255, 224, 0}, "LightYellow"},
+    {{255, 255,   0, 0}, "yellow"},
+    {{255, 215,   0, 0}, "gold"},
+    {{238, 221, 130, 0}, "light"},
+    {{238, 221, 130, 0}, "LightGoldenrod"},
+    {{218, 165,  32, 0}, "goldenrod"},
+    {{184, 134,  11, 0}, "dark"},
+    {{184, 134,  11, 0}, "DarkGoldenrod"},
+    {{188, 143, 143, 0}, "rosy"},
+    {{188, 143, 143, 0}, "RosyBrown"},
+    {{205,  92,  92, 0}, "indian"},
+    {{205,  92,  92, 0}, "IndianRed"},
+    {{139,  69,  19, 0}, "saddle"},
+    {{139,  69,  19, 0}, "SaddleBrown"},
+    {{160,  82,  45, 0}, "sienna"},
+    {{205, 133,  63, 0}, "peru"},
+    {{222, 184, 135, 0}, "burlywood"},
+    {{245, 245, 220, 0}, "beige"},
+    {{245, 222, 179, 0}, "wheat"},
+    {{244, 164,  96, 0}, "sandy"},
+    {{244, 164,  96, 0}, "SandyBrown"},
+    {{210, 180, 140, 0}, "tan"},
+    {{210, 105,  30, 0}, "chocolate"},
+    {{178,  34,  34, 0}, "firebrick"},
+    {{165,  42,  42, 0}, "brown"},
+    {{233, 150, 122, 0}, "dark"},
+    {{233, 150, 122, 0}, "DarkSalmon"},
+    {{250, 128, 114, 0}, "salmon"},
+    {{255, 160, 122, 0}, "light"},
+    {{255, 160, 122, 0}, "LightSalmon"},
+    {{255, 165,   0, 0}, "orange"},
+    {{255, 140,   0, 0}, "dark"},
+    {{255, 140,   0, 0}, "DarkOrange"},
+    {{255, 127,  80, 0}, "coral"},
+    {{240, 128, 128, 0}, "light"},
+    {{240, 128, 128, 0}, "LightCoral"},
+    {{255,  99,  71, 0}, "tomato"},
+    {{255,  69,   0, 0}, "orange"},
+    {{255,  69,   0, 0}, "OrangeRed"},
+    {{255,   0,   0, 0}, "red"},
+    {{255, 105, 180, 0}, "hot"},
+    {{255, 105, 180, 0}, "HotPink"},
+    {{255,  20, 147, 0}, "deep"},
+    {{255,  20, 147, 0}, "DeepPink"},
+    {{255, 192, 203, 0}, "pink"},
+    {{255, 182, 193, 0}, "light"},
+    {{255, 182, 193, 0}, "LightPink"},
+    {{219, 112, 147, 0}, "pale"},
+    {{219, 112, 147, 0}, "PaleVioletRed"},
+    {{176,  48,  96, 0}, "maroon"},
+    {{199,  21, 133, 0}, "medium"},
+    {{199,  21, 133, 0}, "MediumVioletRed"},
+    {{208,  32, 144, 0}, "violet"},
+    {{208,  32, 144, 0}, "VioletRed"},
+    {{255,   0, 255, 0}, "magenta"},
+    {{238, 130, 238, 0}, "violet"},
+    {{221, 160, 221, 0}, "plum"},
+    {{218, 112, 214, 0}, "orchid"},
+    {{186,  85, 211, 0}, "medium"},
+    {{186,  85, 211, 0}, "MediumOrchid"},
+    {{153,  50, 204, 0}, "dark"},
+    {{153,  50, 204, 0}, "DarkOrchid"},
+    {{148,   0, 211, 0}, "dark"},
+    {{148,   0, 211, 0}, "DarkViolet"},
+    {{138,  43, 226, 0}, "blue"},
+    {{138,  43, 226, 0}, "BlueViolet"},
+    {{160,  32, 240, 0}, "purple"},
+    {{147, 112, 219, 0}, "medium"},
+    {{147, 112, 219, 0}, "MediumPurple"},
+    {{216, 191, 216, 0}, "thistle"},
+    {{255, 250, 250, 0}, "snow1"},
+    {{238, 233, 233, 0}, "snow2"},
+    {{205, 201, 201, 0}, "snow3"},
+    {{139, 137, 137, 0}, "snow4"},
+    {{255, 245, 238, 0}, "seashell1"},
+    {{238, 229, 222, 0}, "seashell2"},
+    {{205, 197, 191, 0}, "seashell3"},
+    {{139, 134, 130, 0}, "seashell4"},
+    {{255, 239, 219, 0}, "AntiqueWhite1"},
+    {{238, 223, 204, 0}, "AntiqueWhite2"},
+    {{205, 192, 176, 0}, "AntiqueWhite3"},
+    {{139, 131, 120, 0}, "AntiqueWhite4"},
+    {{255, 228, 196, 0}, "bisque1"},
+    {{238, 213, 183, 0}, "bisque2"},
+    {{205, 183, 158, 0}, "bisque3"},
+    {{139, 125, 107, 0}, "bisque4"},
+    {{255, 218, 185, 0}, "PeachPuff1"},
+    {{238, 203, 173, 0}, "PeachPuff2"},
+    {{205, 175, 149, 0}, "PeachPuff3"},
+    {{139, 119, 101, 0}, "PeachPuff4"},
+    {{255, 222, 173, 0}, "NavajoWhite1"},
+    {{238, 207, 161, 0}, "NavajoWhite2"},
+    {{205, 179, 139, 0}, "NavajoWhite3"},
+    {{139, 121,  94, 0}, "NavajoWhite4"},
+    {{255, 250, 205, 0}, "LemonChiffon1"},
+    {{238, 233, 191, 0}, "LemonChiffon2"},
+    {{205, 201, 165, 0}, "LemonChiffon3"},
+    {{139, 137, 112, 0}, "LemonChiffon4"},
+    {{255, 248, 220, 0}, "cornsilk1"},
+    {{238, 232, 205, 0}, "cornsilk2"},
+    {{205, 200, 177, 0}, "cornsilk3"},
+    {{139, 136, 120, 0}, "cornsilk4"},
+    {{255, 255, 240, 0}, "ivory1"},
+    {{238, 238, 224, 0}, "ivory2"},
+    {{205, 205, 193, 0}, "ivory3"},
+    {{139, 139, 131, 0}, "ivory4"},
+    {{240, 255, 240, 0}, "honeydew1"},
+    {{224, 238, 224, 0}, "honeydew2"},
+    {{193, 205, 193, 0}, "honeydew3"},
+    {{131, 139, 131, 0}, "honeydew4"},
+    {{255, 240, 245, 0}, "LavenderBlush1"},
+    {{238, 224, 229, 0}, "LavenderBlush2"},
+    {{205, 193, 197, 0}, "LavenderBlush3"},
+    {{139, 131, 134, 0}, "LavenderBlush4"},
+    {{255, 228, 225, 0}, "MistyRose1"},
+    {{238, 213, 210, 0}, "MistyRose2"},
+    {{205, 183, 181, 0}, "MistyRose3"},
+    {{139, 125, 123, 0}, "MistyRose4"},
+    {{240, 255, 255, 0}, "azure1"},
+    {{224, 238, 238, 0}, "azure2"},
+    {{193, 205, 205, 0}, "azure3"},
+    {{131, 139, 139, 0}, "azure4"},
+    {{131, 111, 255, 0}, "SlateBlue1"},
+    {{122, 103, 238, 0}, "SlateBlue2"},
+    {{105,  89, 205, 0}, "SlateBlue3"},
+    {{ 71,  60, 139, 0}, "SlateBlue4"},
+    {{ 72, 118, 255, 0}, "RoyalBlue1"},
+    {{ 67, 110, 238, 0}, "RoyalBlue2"},
+    {{ 58,  95, 205, 0}, "RoyalBlue3"},
+    {{ 39,  64, 139, 0}, "RoyalBlue4"},
+    {{  0,   0, 255, 0}, "blue1"},
+    {{  0,   0, 238, 0}, "blue2"},
+    {{  0,   0, 205, 0}, "blue3"},
+    {{  0,   0, 139, 0}, "blue4"},
+    {{ 30, 144, 255, 0}, "DodgerBlue1"},
+    {{ 28, 134, 238, 0}, "DodgerBlue2"},
+    {{ 24, 116, 205, 0}, "DodgerBlue3"},
+    {{ 16,  78, 139, 0}, "DodgerBlue4"},
+    {{ 99, 184, 255, 0}, "SteelBlue1"},
+    {{ 92, 172, 238, 0}, "SteelBlue2"},
+    {{ 79, 148, 205, 0}, "SteelBlue3"},
+    {{ 54, 100, 139, 0}, "SteelBlue4"},
+    {{  0, 191, 255, 0}, "DeepSkyBlue1"},
+    {{  0, 178, 238, 0}, "DeepSkyBlue2"},
+    {{  0, 154, 205, 0}, "DeepSkyBlue3"},
+    {{  0, 104, 139, 0}, "DeepSkyBlue4"},
+    {{135, 206, 255, 0}, "SkyBlue1"},
+    {{126, 192, 238, 0}, "SkyBlue2"},
+    {{108, 166, 205, 0}, "SkyBlue3"},
+    {{ 74, 112, 139, 0}, "SkyBlue4"},
+    {{176, 226, 255, 0}, "LightSkyBlue1"},
+    {{164, 211, 238, 0}, "LightSkyBlue2"},
+    {{141, 182, 205, 0}, "LightSkyBlue3"},
+    {{ 96, 123, 139, 0}, "LightSkyBlue4"},
+    {{198, 226, 255, 0}, "SlateGray1"},
+    {{185, 211, 238, 0}, "SlateGray2"},
+    {{159, 182, 205, 0}, "SlateGray3"},
+    {{108, 123, 139, 0}, "SlateGray4"},
+    {{202, 225, 255, 0}, "LightSteelBlue1"},
+    {{188, 210, 238, 0}, "LightSteelBlue2"},
+    {{162, 181, 205, 0}, "LightSteelBlue3"},
+    {{110, 123, 139, 0}, "LightSteelBlue4"},
+    {{191, 239, 255, 0}, "LightBlue1"},
+    {{178, 223, 238, 0}, "LightBlue2"},
+    {{154, 192, 205, 0}, "LightBlue3"},
+    {{104, 131, 139, 0}, "LightBlue4"},
+    {{224, 255, 255, 0}, "LightCyan1"},
+    {{209, 238, 238, 0}, "LightCyan2"},
+    {{180, 205, 205, 0}, "LightCyan3"},
+    {{122, 139, 139, 0}, "LightCyan4"},
+    {{187, 255, 255, 0}, "PaleTurquoise1"},
+    {{174, 238, 238, 0}, "PaleTurquoise2"},
+    {{150, 205, 205, 0}, "PaleTurquoise3"},
+    {{102, 139, 139, 0}, "PaleTurquoise4"},
+    {{152, 245, 255, 0}, "CadetBlue1"},
+    {{142, 229, 238, 0}, "CadetBlue2"},
+    {{122, 197, 205, 0}, "CadetBlue3"},
+    {{ 83, 134, 139, 0}, "CadetBlue4"},
+    {{  0, 245, 255, 0}, "turquoise1"},
+    {{  0, 229, 238, 0}, "turquoise2"},
+    {{  0, 197, 205, 0}, "turquoise3"},
+    {{  0, 134, 139, 0}, "turquoise4"},
+    {{  0, 255, 255, 0}, "cyan1"},
+    {{  0, 238, 238, 0}, "cyan2"},
+    {{  0, 205, 205, 0}, "cyan3"},
+    {{  0, 139, 139, 0}, "cyan4"},
+    {{151, 255, 255, 0}, "DarkSlateGray1"},
+    {{141, 238, 238, 0}, "DarkSlateGray2"},
+    {{121, 205, 205, 0}, "DarkSlateGray3"},
+    {{ 82, 139, 139, 0}, "DarkSlateGray4"},
+    {{127, 255, 212, 0}, "aquamarine1"},
+    {{118, 238, 198, 0}, "aquamarine2"},
+    {{102, 205, 170, 0}, "aquamarine3"},
+    {{ 69, 139, 116, 0}, "aquamarine4"},
+    {{193, 255, 193, 0}, "DarkSeaGreen1"},
+    {{180, 238, 180, 0}, "DarkSeaGreen2"},
+    {{155, 205, 155, 0}, "DarkSeaGreen3"},
+    {{105, 139, 105, 0}, "DarkSeaGreen4"},
+    {{ 84, 255, 159, 0}, "SeaGreen1"},
+    {{ 78, 238, 148, 0}, "SeaGreen2"},
+    {{ 67, 205, 128, 0}, "SeaGreen3"},
+    {{ 46, 139,  87, 0}, "SeaGreen4"},
+    {{154, 255, 154, 0}, "PaleGreen1"},
+    {{144, 238, 144, 0}, "PaleGreen2"},
+    {{124, 205, 124, 0}, "PaleGreen3"},
+    {{ 84, 139,  84, 0}, "PaleGreen4"},
+    {{  0, 255, 127, 0}, "SpringGreen1"},
+    {{  0, 238, 118, 0}, "SpringGreen2"},
+    {{  0, 205, 102, 0}, "SpringGreen3"},
+    {{  0, 139,  69, 0}, "SpringGreen4"},
+    {{  0, 255,   0, 0}, "green1"},
+    {{  0, 238,   0, 0}, "green2"},
+    {{  0, 205,   0, 0}, "green3"},
+    {{  0, 139,   0, 0}, "green4"},
+    {{127, 255,   0, 0}, "chartreuse1"},
+    {{118, 238,   0, 0}, "chartreuse2"},
+    {{102, 205,   0, 0}, "chartreuse3"},
+    {{ 69, 139,   0, 0}, "chartreuse4"},
+    {{192, 255,  62, 0}, "OliveDrab1"},
+    {{179, 238,  58, 0}, "OliveDrab2"},
+    {{154, 205,  50, 0}, "OliveDrab3"},
+    {{105, 139,  34, 0}, "OliveDrab4"},
+    {{202, 255, 112, 0}, "DarkOliveGreen1"},
+    {{188, 238, 104, 0}, "DarkOliveGreen2"},
+    {{162, 205,  90, 0}, "DarkOliveGreen3"},
+    {{110, 139,  61, 0}, "DarkOliveGreen4"},
+    {{255, 246, 143, 0}, "khaki1"},
+    {{238, 230, 133, 0}, "khaki2"},
+    {{205, 198, 115, 0}, "khaki3"},
+    {{139, 134,  78, 0}, "khaki4"},
+    {{255, 236, 139, 0}, "LightGoldenrod1"},
+    {{238, 220, 130, 0}, "LightGoldenrod2"},
+    {{205, 190, 112, 0}, "LightGoldenrod3"},
+    {{139, 129,  76, 0}, "LightGoldenrod4"},
+    {{255, 255, 224, 0}, "LightYellow1"},
+    {{238, 238, 209, 0}, "LightYellow2"},
+    {{205, 205, 180, 0}, "LightYellow3"},
+    {{139, 139, 122, 0}, "LightYellow4"},
+    {{255, 255,   0, 0}, "yellow1"},
+    {{238, 238,   0, 0}, "yellow2"},
+    {{205, 205,   0, 0}, "yellow3"},
+    {{139, 139,   0, 0}, "yellow4"},
+    {{255, 215,   0, 0}, "gold1"},
+    {{238, 201,   0, 0}, "gold2"},
+    {{205, 173,   0, 0}, "gold3"},
+    {{139, 117,   0, 0}, "gold4"},
+    {{255, 193,  37, 0}, "goldenrod1"},
+    {{238, 180,  34, 0}, "goldenrod2"},
+    {{205, 155,  29, 0}, "goldenrod3"},
+    {{139, 105,  20, 0}, "goldenrod4"},
+    {{255, 185,  15, 0}, "DarkGoldenrod1"},
+    {{238, 173,  14, 0}, "DarkGoldenrod2"},
+    {{205, 149,  12, 0}, "DarkGoldenrod3"},
+    {{139, 101,   8, 0}, "DarkGoldenrod4"},
+    {{255, 193, 193, 0}, "RosyBrown1"},
+    {{238, 180, 180, 0}, "RosyBrown2"},
+    {{205, 155, 155, 0}, "RosyBrown3"},
+    {{139, 105, 105, 0}, "RosyBrown4"},
+    {{255, 106, 106, 0}, "IndianRed1"},
+    {{238,  99,  99, 0}, "IndianRed2"},
+    {{205,  85,  85, 0}, "IndianRed3"},
+    {{139,  58,  58, 0}, "IndianRed4"},
+    {{255, 130,  71, 0}, "sienna1"},
+    {{238, 121,  66, 0}, "sienna2"},
+    {{205, 104,  57, 0}, "sienna3"},
+    {{139,  71,  38, 0}, "sienna4"},
+    {{255, 211, 155, 0}, "burlywood1"},
+    {{238, 197, 145, 0}, "burlywood2"},
+    {{205, 170, 125, 0}, "burlywood3"},
+    {{139, 115,  85, 0}, "burlywood4"},
+    {{255, 231, 186, 0}, "wheat1"},
+    {{238, 216, 174, 0}, "wheat2"},
+    {{205, 186, 150, 0}, "wheat3"},
+    {{139, 126, 102, 0}, "wheat4"},
+    {{255, 165,  79, 0}, "tan1"},
+    {{238, 154,  73, 0}, "tan2"},
+    {{205, 133,  63, 0}, "tan3"},
+    {{139,  90,  43, 0}, "tan4"},
+    {{255, 127,  36, 0}, "chocolate1"},
+    {{238, 118,  33, 0}, "chocolate2"},
+    {{205, 102,  29, 0}, "chocolate3"},
+    {{139,  69,  19, 0}, "chocolate4"},
+    {{255,  48,  48, 0}, "firebrick1"},
+    {{238,  44,  44, 0}, "firebrick2"},
+    {{205,  38,  38, 0}, "firebrick3"},
+    {{139,  26,  26, 0}, "firebrick4"},
+    {{255,  64,  64, 0}, "brown1"},
+    {{238,  59,  59, 0}, "brown2"},
+    {{205,  51,  51, 0}, "brown3"},
+    {{139,  35,  35, 0}, "brown4"},
+    {{255, 140, 105, 0}, "salmon1"},
+    {{238, 130,  98, 0}, "salmon2"},
+    {{205, 112,  84, 0}, "salmon3"},
+    {{139,  76,  57, 0}, "salmon4"},
+    {{255, 160, 122, 0}, "LightSalmon1"},
+    {{238, 149, 114, 0}, "LightSalmon2"},
+    {{205, 129,  98, 0}, "LightSalmon3"},
+    {{139,  87,  66, 0}, "LightSalmon4"},
+    {{255, 165,   0, 0}, "orange1"},
+    {{238, 154,   0, 0}, "orange2"},
+    {{205, 133,   0, 0}, "orange3"},
+    {{139,  90,   0, 0}, "orange4"},
+    {{255, 127,   0, 0}, "DarkOrange1"},
+    {{238, 118,   0, 0}, "DarkOrange2"},
+    {{205, 102,   0, 0}, "DarkOrange3"},
+    {{139,  69,   0, 0}, "DarkOrange4"},
+    {{255, 114,  86, 0}, "coral1"},
+    {{238, 106,  80, 0}, "coral2"},
+    {{205,  91,  69, 0}, "coral3"},
+    {{139,  62,  47, 0}, "coral4"},
+    {{255,  99,  71, 0}, "tomato1"},
+    {{238,  92,  66, 0}, "tomato2"},
+    {{205,  79,  57, 0}, "tomato3"},
+    {{139,  54,  38, 0}, "tomato4"},
+    {{255,  69,   0, 0}, "OrangeRed1"},
+    {{238,  64,   0, 0}, "OrangeRed2"},
+    {{205,  55,   0, 0}, "OrangeRed3"},
+    {{139,  37,   0, 0}, "OrangeRed4"},
+    {{255,   0,   0, 0}, "red1"},
+    {{238,   0,   0, 0}, "red2"},
+    {{205,   0,   0, 0}, "red3"},
+    {{139,   0,   0, 0}, "red4"},
+    {{255,  20, 147, 0}, "DeepPink1"},
+    {{238,  18, 137, 0}, "DeepPink2"},
+    {{205,  16, 118, 0}, "DeepPink3"},
+    {{139,  10,  80, 0}, "DeepPink4"},
+    {{255, 110, 180, 0}, "HotPink1"},
+    {{238, 106, 167, 0}, "HotPink2"},
+    {{205,  96, 144, 0}, "HotPink3"},
+    {{139,  58,  98, 0}, "HotPink4"},
+    {{255, 181, 197, 0}, "pink1"},
+    {{238, 169, 184, 0}, "pink2"},
+    {{205, 145, 158, 0}, "pink3"},
+    {{139,  99, 108, 0}, "pink4"},
+    {{255, 174, 185, 0}, "LightPink1"},
+    {{238, 162, 173, 0}, "LightPink2"},
+    {{205, 140, 149, 0}, "LightPink3"},
+    {{139,  95, 101, 0}, "LightPink4"},
+    {{255, 130, 171, 0}, "PaleVioletRed1"},
+    {{238, 121, 159, 0}, "PaleVioletRed2"},
+    {{205, 104, 137, 0}, "PaleVioletRed3"},
+    {{139,  71,  93, 0}, "PaleVioletRed4"},
+    {{255,  52, 179, 0}, "maroon1"},
+    {{238,  48, 167, 0}, "maroon2"},
+    {{205,  41, 144, 0}, "maroon3"},
+    {{139,  28,  98, 0}, "maroon4"},
+    {{255,  62, 150, 0}, "VioletRed1"},
+    {{238,  58, 140, 0}, "VioletRed2"},
+    {{205,  50, 120, 0}, "VioletRed3"},
+    {{139,  34,  82, 0}, "VioletRed4"},
+    {{255,   0, 255, 0}, "magenta1"},
+    {{238,   0, 238, 0}, "magenta2"},
+    {{205,   0, 205, 0}, "magenta3"},
+    {{139,   0, 139, 0}, "magenta4"},
+    {{255, 131, 250, 0}, "orchid1"},
+    {{238, 122, 233, 0}, "orchid2"},
+    {{205, 105, 201, 0}, "orchid3"},
+    {{139,  71, 137, 0}, "orchid4"},
+    {{255, 187, 255, 0}, "plum1"},
+    {{238, 174, 238, 0}, "plum2"},
+    {{205, 150, 205, 0}, "plum3"},
+    {{139, 102, 139, 0}, "plum4"},
+    {{224, 102, 255, 0}, "MediumOrchid1"},
+    {{209,  95, 238, 0}, "MediumOrchid2"},
+    {{180,  82, 205, 0}, "MediumOrchid3"},
+    {{122,  55, 139, 0}, "MediumOrchid4"},
+    {{191,  62, 255, 0}, "DarkOrchid1"},
+    {{178,  58, 238, 0}, "DarkOrchid2"},
+    {{154,  50, 205, 0}, "DarkOrchid3"},
+    {{104,  34, 139, 0}, "DarkOrchid4"},
+    {{155,  48, 255, 0}, "purple1"},
+    {{145,  44, 238, 0}, "purple2"},
+    {{125,  38, 205, 0}, "purple3"},
+    {{ 85,  26, 139, 0}, "purple4"},
+    {{171, 130, 255, 0}, "MediumPurple1"},
+    {{159, 121, 238, 0}, "MediumPurple2"},
+    {{137, 104, 205, 0}, "MediumPurple3"},
+    {{ 93,  71, 139, 0}, "MediumPurple4"},
+    {{255, 225, 255, 0}, "thistle1"},
+    {{238, 210, 238, 0}, "thistle2"},
+    {{205, 181, 205, 0}, "thistle3"},
+    {{139, 123, 139, 0}, "thistle4"},
+    {{  0,   0,   0, 0}, "gray0"},
+    {{  0,   0,   0, 0}, "grey0"},
+    {{  3,   3,   3, 0}, "gray1"},
+    {{  3,   3,   3, 0}, "grey1"},
+    {{  5,   5,   5, 0}, "gray2"},
+    {{  5,   5,   5, 0}, "grey2"},
+    {{  8,   8,   8, 0}, "gray3"},
+    {{  8,   8,   8, 0}, "grey3"},
+    {{ 10,  10,  10, 0}, "gray4"},
+    {{ 10,  10,  10, 0}, "grey4"},
+    {{ 13,  13,  13, 0}, "gray5"},
+    {{ 13,  13,  13, 0}, "grey5"},
+    {{ 15,  15,  15, 0}, "gray6"},
+    {{ 15,  15,  15, 0}, "grey6"},
+    {{ 18,  18,  18, 0}, "gray7"},
+    {{ 18,  18,  18, 0}, "grey7"},
+    {{ 20,  20,  20, 0}, "gray8"},
+    {{ 20,  20,  20, 0}, "grey8"},
+    {{ 23,  23,  23, 0}, "gray9"},
+    {{ 23,  23,  23, 0}, "grey9"},
+    {{ 26,  26,  26, 0}, "gray10"},
+    {{ 26,  26,  26, 0}, "grey10"},
+    {{ 28,  28,  28, 0}, "gray11"},
+    {{ 28,  28,  28, 0}, "grey11"},
+    {{ 31,  31,  31, 0}, "gray12"},
+    {{ 31,  31,  31, 0}, "grey12"},
+    {{ 33,  33,  33, 0}, "gray13"},
+    {{ 33,  33,  33, 0}, "grey13"},
+    {{ 36,  36,  36, 0}, "gray14"},
+    {{ 36,  36,  36, 0}, "grey14"},
+    {{ 38,  38,  38, 0}, "gray15"},
+    {{ 38,  38,  38, 0}, "grey15"},
+    {{ 41,  41,  41, 0}, "gray16"},
+    {{ 41,  41,  41, 0}, "grey16"},
+    {{ 43,  43,  43, 0}, "gray17"},
+    {{ 43,  43,  43, 0}, "grey17"},
+    {{ 46,  46,  46, 0}, "gray18"},
+    {{ 46,  46,  46, 0}, "grey18"},
+    {{ 48,  48,  48, 0}, "gray19"},
+    {{ 48,  48,  48, 0}, "grey19"},
+    {{ 51,  51,  51, 0}, "gray20"},
+    {{ 51,  51,  51, 0}, "grey20"},
+    {{ 54,  54,  54, 0}, "gray21"},
+    {{ 54,  54,  54, 0}, "grey21"},
+    {{ 56,  56,  56, 0}, "gray22"},
+    {{ 56,  56,  56, 0}, "grey22"},
+    {{ 59,  59,  59, 0}, "gray23"},
+    {{ 59,  59,  59, 0}, "grey23"},
+    {{ 61,  61,  61, 0}, "gray24"},
+    {{ 61,  61,  61, 0}, "grey24"},
+    {{ 64,  64,  64, 0}, "gray25"},
+    {{ 64,  64,  64, 0}, "grey25"},
+    {{ 66,  66,  66, 0}, "gray26"},
+    {{ 66,  66,  66, 0}, "grey26"},
+    {{ 69,  69,  69, 0}, "gray27"},
+    {{ 69,  69,  69, 0}, "grey27"},
+    {{ 71,  71,  71, 0}, "gray28"},
+    {{ 71,  71,  71, 0}, "grey28"},
+    {{ 74,  74,  74, 0}, "gray29"},
+    {{ 74,  74,  74, 0}, "grey29"},
+    {{ 77,  77,  77, 0}, "gray30"},
+    {{ 77,  77,  77, 0}, "grey30"},
+    {{ 79,  79,  79, 0}, "gray31"},
+    {{ 79,  79,  79, 0}, "grey31"},
+    {{ 82,  82,  82, 0}, "gray32"},
+    {{ 82,  82,  82, 0}, "grey32"},
+    {{ 84,  84,  84, 0}, "gray33"},
+    {{ 84,  84,  84, 0}, "grey33"},
+    {{ 87,  87,  87, 0}, "gray34"},
+    {{ 87,  87,  87, 0}, "grey34"},
+    {{ 89,  89,  89, 0}, "gray35"},
+    {{ 89,  89,  89, 0}, "grey35"},
+    {{ 92,  92,  92, 0}, "gray36"},
+    {{ 92,  92,  92, 0}, "grey36"},
+    {{ 94,  94,  94, 0}, "gray37"},
+    {{ 94,  94,  94, 0}, "grey37"},
+    {{ 97,  97,  97, 0}, "gray38"},
+    {{ 97,  97,  97, 0}, "grey38"},
+    {{ 99,  99,  99, 0}, "gray39"},
+    {{ 99,  99,  99, 0}, "grey39"},
+    {{102, 102, 102, 0}, "gray40"},
+    {{102, 102, 102, 0}, "grey40"},
+    {{105, 105, 105, 0}, "gray41"},
+    {{105, 105, 105, 0}, "grey41"},
+    {{107, 107, 107, 0}, "gray42"},
+    {{107, 107, 107, 0}, "grey42"},
+    {{110, 110, 110, 0}, "gray43"},
+    {{110, 110, 110, 0}, "grey43"},
+    {{112, 112, 112, 0}, "gray44"},
+    {{112, 112, 112, 0}, "grey44"},
+    {{115, 115, 115, 0}, "gray45"},
+    {{115, 115, 115, 0}, "grey45"},
+    {{117, 117, 117, 0}, "gray46"},
+    {{117, 117, 117, 0}, "grey46"},
+    {{120, 120, 120, 0}, "gray47"},
+    {{120, 120, 120, 0}, "grey47"},
+    {{122, 122, 122, 0}, "gray48"},
+    {{122, 122, 122, 0}, "grey48"},
+    {{125, 125, 125, 0}, "gray49"},
+    {{125, 125, 125, 0}, "grey49"},
+    {{127, 127, 127, 0}, "gray50"},
+    {{127, 127, 127, 0}, "grey50"},
+    {{130, 130, 130, 0}, "gray51"},
+    {{130, 130, 130, 0}, "grey51"},
+    {{133, 133, 133, 0}, "gray52"},
+    {{133, 133, 133, 0}, "grey52"},
+    {{135, 135, 135, 0}, "gray53"},
+    {{135, 135, 135, 0}, "grey53"},
+    {{138, 138, 138, 0}, "gray54"},
+    {{138, 138, 138, 0}, "grey54"},
+    {{140, 140, 140, 0}, "gray55"},
+    {{140, 140, 140, 0}, "grey55"},
+    {{143, 143, 143, 0}, "gray56"},
+    {{143, 143, 143, 0}, "grey56"},
+    {{145, 145, 145, 0}, "gray57"},
+    {{145, 145, 145, 0}, "grey57"},
+    {{148, 148, 148, 0}, "gray58"},
+    {{148, 148, 148, 0}, "grey58"},
+    {{150, 150, 150, 0}, "gray59"},
+    {{150, 150, 150, 0}, "grey59"},
+    {{153, 153, 153, 0}, "gray60"},
+    {{153, 153, 153, 0}, "grey60"},
+    {{156, 156, 156, 0}, "gray61"},
+    {{156, 156, 156, 0}, "grey61"},
+    {{158, 158, 158, 0}, "gray62"},
+    {{158, 158, 158, 0}, "grey62"},
+    {{161, 161, 161, 0}, "gray63"},
+    {{161, 161, 161, 0}, "grey63"},
+    {{163, 163, 163, 0}, "gray64"},
+    {{163, 163, 163, 0}, "grey64"},
+    {{166, 166, 166, 0}, "gray65"},
+    {{166, 166, 166, 0}, "grey65"},
+    {{168, 168, 168, 0}, "gray66"},
+    {{168, 168, 168, 0}, "grey66"},
+    {{171, 171, 171, 0}, "gray67"},
+    {{171, 171, 171, 0}, "grey67"},
+    {{173, 173, 173, 0}, "gray68"},
+    {{173, 173, 173, 0}, "grey68"},
+    {{176, 176, 176, 0}, "gray69"},
+    {{176, 176, 176, 0}, "grey69"},
+    {{179, 179, 179, 0}, "gray70"},
+    {{179, 179, 179, 0}, "grey70"},
+    {{181, 181, 181, 0}, "gray71"},
+    {{181, 181, 181, 0}, "grey71"},
+    {{184, 184, 184, 0}, "gray72"},
+    {{184, 184, 184, 0}, "grey72"},
+    {{186, 186, 186, 0}, "gray73"},
+    {{186, 186, 186, 0}, "grey73"},
+    {{189, 189, 189, 0}, "gray74"},
+    {{189, 189, 189, 0}, "grey74"},
+    {{191, 191, 191, 0}, "gray75"},
+    {{191, 191, 191, 0}, "grey75"},
+    {{194, 194, 194, 0}, "gray76"},
+    {{194, 194, 194, 0}, "grey76"},
+    {{196, 196, 196, 0}, "gray77"},
+    {{196, 196, 196, 0}, "grey77"},
+    {{199, 199, 199, 0}, "gray78"},
+    {{199, 199, 199, 0}, "grey78"},
+    {{201, 201, 201, 0}, "gray79"},
+    {{201, 201, 201, 0}, "grey79"},
+    {{204, 204, 204, 0}, "gray80"},
+    {{204, 204, 204, 0}, "grey80"},
+    {{207, 207, 207, 0}, "gray81"},
+    {{207, 207, 207, 0}, "grey81"},
+    {{209, 209, 209, 0}, "gray82"},
+    {{209, 209, 209, 0}, "grey82"},
+    {{212, 212, 212, 0}, "gray83"},
+    {{212, 212, 212, 0}, "grey83"},
+    {{214, 214, 214, 0}, "gray84"},
+    {{214, 214, 214, 0}, "grey84"},
+    {{217, 217, 217, 0}, "gray85"},
+    {{217, 217, 217, 0}, "grey85"},
+    {{219, 219, 219, 0}, "gray86"},
+    {{219, 219, 219, 0}, "grey86"},
+    {{222, 222, 222, 0}, "gray87"},
+    {{222, 222, 222, 0}, "grey87"},
+    {{224, 224, 224, 0}, "gray88"},
+    {{224, 224, 224, 0}, "grey88"},
+    {{227, 227, 227, 0}, "gray89"},
+    {{227, 227, 227, 0}, "grey89"},
+    {{229, 229, 229, 0}, "gray90"},
+    {{229, 229, 229, 0}, "grey90"},
+    {{232, 232, 232, 0}, "gray91"},
+    {{232, 232, 232, 0}, "grey91"},
+    {{235, 235, 235, 0}, "gray92"},
+    {{235, 235, 235, 0}, "grey92"},
+    {{237, 237, 237, 0}, "gray93"},
+    {{237, 237, 237, 0}, "grey93"},
+    {{240, 240, 240, 0}, "gray94"},
+    {{240, 240, 240, 0}, "grey94"},
+    {{242, 242, 242, 0}, "gray95"},
+    {{242, 242, 242, 0}, "grey95"},
+    {{245, 245, 245, 0}, "gray96"},
+    {{245, 245, 245, 0}, "grey96"},
+    {{247, 247, 247, 0}, "gray97"},
+    {{247, 247, 247, 0}, "grey97"},
+    {{250, 250, 250, 0}, "gray98"},
+    {{250, 250, 250, 0}, "grey98"},
+    {{252, 252, 252, 0}, "gray99"},
+    {{252, 252, 252, 0}, "grey99"},
+    {{255, 255, 255, 0}, "gray100"},
+    {{255, 255, 255, 0}, "grey100"},
+    {{169, 169, 169, 0}, "dark"},
+    {{169, 169, 169, 0}, "DarkGrey"},
+    {{169, 169, 169, 0}, "dark"},
+    {{169, 169, 169, 0}, "DarkGray"},
+    {{  0,   0, 139, 0}, "dark"},
+    {{  0,   0, 139, 0}, "DarkBlue"},
+    {{  0, 139, 139, 0}, "dark"},
+    {{  0, 139, 139, 0}, "DarkCyan"},
+    {{139,   0, 139, 0}, "dark"},
+    {{139,   0, 139, 0}, "DarkMagenta"},
+    {{139,   0,   0, 0}, "dark"},
+    {{139,   0,   0, 0}, "DarkRed"},
+    {{144, 238, 144, 0}, "light"},
+    {{144, 238, 144, 0}, "LightGreen"},
+    {{  0,   0,   0, 0}, NULL}
+};
+
+#endif
+

bazel/WINGs/selection.c

@@ -0,0 +1,393 @@
+
+#include <stdlib.h>
+
+#include <X11/Xatom.h>
+
+#include "WINGs/WINGsP.h"
+
+#define MAX_PROPERTY_SIZE 8*1024
+
+const char *WMSelectionOwnerDidChangeNotification = "WMSelectionOwnerDidChange";
+
+typedef struct SelectionHandler {
+	WMView *view;
+	Atom selection;
+	Time timestamp;
+	WMSelectionProcs procs;
+	void *data;
+
+	struct {
+		unsigned delete_pending:1;
+		unsigned done_pending:1;
+	} flags;
+} SelectionHandler;
+
+typedef struct SelectionCallback {
+	WMView *view;
+	Atom selection;
+	Atom target;
+	Time timestamp;
+	WMSelectionCallback *callback;
+	void *data;
+
+	struct {
+		unsigned delete_pending:1;
+		unsigned done_pending:1;
+	} flags;
+} SelectionCallback;
+
+static WMArray *selCallbacks = NULL;
+
+static WMArray *selHandlers = NULL;
+
+static Bool gotXError = False;
+
+void WMDeleteSelectionHandler(WMView * view, Atom selection, Time timestamp)
+{
+	SelectionHandler *handler;
+	Display *dpy = W_VIEW_SCREEN(view)->display;
+	Window win = W_VIEW_DRAWABLE(view);
+	WMArrayIterator iter;
+
+	if (!selHandlers)
+		return;
+
+	/*//printf("deleting selection handler for %d", win); */
+
+	WM_ITERATE_ARRAY(selHandlers, handler, iter) {
+		if (handler->view == view && (handler->selection == selection || selection == None)
+		    && (handler->timestamp == timestamp || timestamp == CurrentTime)) {
+
+			if (handler->flags.done_pending) {
+				handler->flags.delete_pending = 1;
+				/*//puts(": postponed because still pending"); */
+				return;
+			}
+			/*//printf(": found & removed"); */
+			WMRemoveFromArray(selHandlers, handler);
+			break;
+		}
+	}
+
+	/*//printf("\n"); */
+
+	XGrabServer(dpy);
+	if (XGetSelectionOwner(dpy, selection) == win) {
+		XSetSelectionOwner(dpy, selection, None, timestamp);
+	}
+	XUngrabServer(dpy);
+}
+
+static void WMDeleteSelectionCallback(WMView * view, Atom selection, Time timestamp)
+{
+	SelectionCallback *handler;
+	WMArrayIterator iter;
+
+	if (!selCallbacks)
+		return;
+
+	WM_ITERATE_ARRAY(selCallbacks, handler, iter) {
+		if (handler->view == view && (handler->selection == selection || selection == None)
+		    && (handler->timestamp == timestamp || timestamp == CurrentTime)) {
+
+			if (handler->flags.done_pending) {
+				handler->flags.delete_pending = 1;
+				return;
+			}
+			WMRemoveFromArray(selCallbacks, handler);
+			break;
+		}
+	}
+}
+
+static int handleXError(Display * dpy, XErrorEvent * ev)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) dpy;
+	(void) ev;
+
+	gotXError = True;
+
+	return 1;
+}
+
+static Bool writeSelection(Display * dpy, Window requestor, Atom property, Atom type, WMData * data)
+{
+	static void *oldHandler;
+	int format, bpi;
+
+	format = WMGetDataFormat(data);
+	if (format == 0)
+		format = 8;
+
+	bpi = format / 8;
+
+	/* printf("write to %x: %s\n", requestor, XGetAtomName(dpy, property)); */
+
+	oldHandler = XSetErrorHandler(handleXError);
+
+	gotXError = False;
+
+	XChangeProperty(dpy, requestor, property, type, format, PropModeReplace,
+			WMDataBytes(data), WMGetDataLength(data) / bpi);
+
+	XFlush(dpy);
+
+	XSetErrorHandler(oldHandler);
+
+	return !gotXError;
+}
+
+static void notifySelection(XEvent * event, Atom prop)
+{
+	XEvent ev;
+
+	/* printf("event to %x\n", event->xselectionrequest.requestor); */
+
+	ev.xselection.type = SelectionNotify;
+	ev.xselection.serial = 0;
+	ev.xselection.send_event = True;
+	ev.xselection.display = event->xselectionrequest.display;
+	ev.xselection.requestor = event->xselectionrequest.requestor;
+	ev.xselection.target = event->xselectionrequest.target;
+	ev.xselection.selection = event->xselectionrequest.selection;
+	ev.xselection.property = prop;
+	ev.xselection.time = event->xselectionrequest.time;
+
+	XSendEvent(event->xany.display, event->xselectionrequest.requestor, False, 0, &ev);
+	XFlush(event->xany.display);
+}
+
+static void handleRequestEvent(XEvent * event)
+{
+	SelectionHandler *handler;
+	WMArrayIterator iter;
+	WMArray *copy;
+	Bool handledRequest;
+
+	WM_ITERATE_ARRAY(selHandlers, handler, iter) {
+
+		switch (event->type) {
+		case SelectionClear:
+			if (W_VIEW_DRAWABLE(handler->view)
+			    != event->xselectionclear.window) {
+				break;
+			}
+
+			handler->flags.done_pending = 1;
+			if (handler->procs.selectionLost)
+				handler->procs.selectionLost(handler->view, handler->selection, handler->data);
+			handler->flags.done_pending = 0;
+			handler->flags.delete_pending = 1;
+			break;
+
+		case SelectionRequest:
+			if (W_VIEW_DRAWABLE(handler->view) != event->xselectionrequest.owner) {
+				break;
+			}
+
+			if (handler->procs.convertSelection != NULL
+			    && handler->selection == event->xselectionrequest.selection) {
+				Atom atom;
+				WMData *data;
+				Atom prop;
+
+				/* they're requesting for something old.. maybe another handler
+				 * can handle it */
+				if (event->xselectionrequest.time < handler->timestamp
+				    && event->xselectionrequest.time != CurrentTime) {
+					break;
+				}
+
+				handledRequest = False;
+
+				handler->flags.done_pending = 1;
+
+				data = handler->procs.convertSelection(handler->view,
+								       handler->selection,
+								       event->xselectionrequest.target,
+								       handler->data, &atom);
+
+				prop = event->xselectionrequest.property;
+				/* obsolete clients that don't set the property field */
+				if (prop == None)
+					prop = event->xselectionrequest.target;
+
+				if (data) {
+					if (writeSelection(event->xselectionrequest.display,
+							   event->xselectionrequest.requestor, prop, atom, data)) {
+						handledRequest = True;
+					}
+					WMReleaseData(data);
+				}
+
+				notifySelection(event, (handledRequest == True ? prop : None));
+
+				if (handler->procs.selectionDone != NULL) {
+					handler->procs.selectionDone(handler->view,
+								     handler->selection,
+								     event->xselectionrequest.target,
+								     handler->data);
+				}
+
+				handler->flags.done_pending = 0;
+			}
+			break;
+		}
+	}
+
+	/* delete handlers */
+	copy = WMDuplicateArray(selHandlers);
+	WM_ITERATE_ARRAY(copy, handler, iter) {
+		if (handler && handler->flags.delete_pending) {
+			WMDeleteSelectionHandler(handler->view, handler->selection, handler->timestamp);
+		}
+	}
+	WMFreeArray(copy);
+}
+
+static WMData *getSelectionData(Display * dpy, Window win, Atom where)
+{
+	WMData *wdata;
+	unsigned char *data;
+	Atom rtype;
+	int bits, bpi;
+	unsigned long len, bytes;
+
+	if (XGetWindowProperty(dpy, win, where, 0, MAX_PROPERTY_SIZE,
+			       False, AnyPropertyType, &rtype, &bits, &len, &bytes, &data) != Success) {
+		return NULL;
+	}
+
+	bpi = bits / 8;
+
+	wdata = WMCreateDataWithBytesNoCopy(data, len * bpi, (void *) XFree);
+	WMSetDataFormat(wdata, bits);
+
+	return wdata;
+}
+
+static void handleNotifyEvent(XEvent * event)
+{
+	SelectionCallback *handler;
+	WMArrayIterator iter;
+	WMArray *copy;
+	WMData *data;
+
+	WM_ITERATE_ARRAY(selCallbacks, handler, iter) {
+
+		if (W_VIEW_DRAWABLE(handler->view) != event->xselection.requestor
+		    || handler->selection != event->xselection.selection) {
+			continue;
+		}
+		handler->flags.done_pending = 1;
+
+		if (event->xselection.property == None) {
+			data = NULL;
+		} else {
+			data = getSelectionData(event->xselection.display,
+						event->xselection.requestor, event->xselection.property);
+		}
+
+		(*handler->callback) (handler->view, handler->selection,
+				      handler->target, handler->timestamp, handler->data, data);
+
+		if (data != NULL) {
+			WMReleaseData(data);
+		}
+		handler->flags.done_pending = 0;
+		handler->flags.delete_pending = 1;
+	}
+
+	/* delete callbacks */
+	copy = WMDuplicateArray(selCallbacks);
+	WM_ITERATE_ARRAY(copy, handler, iter) {
+		if (handler && handler->flags.delete_pending) {
+			WMDeleteSelectionCallback(handler->view, handler->selection, handler->timestamp);
+		}
+	}
+	WMFreeArray(copy);
+}
+
+void W_HandleSelectionEvent(XEvent * event)
+{
+	/*//printf("%d received selection ", event->xany.window); */
+	/*//switch(event->type) {
+	   case SelectionNotify:
+	   puts("notify"); break;
+	   case SelectionRequest:
+	   puts("request"); break;
+	   case SelectionClear:
+	   puts("clear"); break;
+	   default:
+	   puts("unknown"); break;
+	   } */
+
+	if (event->type == SelectionNotify) {
+		handleNotifyEvent(event);
+	} else {
+		handleRequestEvent(event);
+	}
+}
+
+Bool WMCreateSelectionHandler(WMView * view, Atom selection, Time timestamp, WMSelectionProcs * procs, void *cdata)
+{
+	SelectionHandler *handler;
+	Display *dpy = W_VIEW_SCREEN(view)->display;
+
+	XSetSelectionOwner(dpy, selection, W_VIEW_DRAWABLE(view), timestamp);
+	if (XGetSelectionOwner(dpy, selection) != W_VIEW_DRAWABLE(view)) {
+		return False;
+	}
+
+	WMPostNotificationName(WMSelectionOwnerDidChangeNotification, (void *)selection, (void *)view);
+
+	/*//printf("created selection handler for %d\n", W_VIEW_DRAWABLE(view)); */
+
+	handler = wmalloc(sizeof(SelectionHandler));
+	handler->view = view;
+	handler->selection = selection;
+	handler->timestamp = timestamp;
+	handler->procs = *procs;
+	handler->data = cdata;
+	memset(&handler->flags, 0, sizeof(handler->flags));
+
+	if (selHandlers == NULL) {
+		selHandlers = WMCreateArrayWithDestructor(4, wfree);
+	}
+
+	WMAddToArray(selHandlers, handler);
+
+	return True;
+}
+
+Bool
+WMRequestSelection(WMView * view, Atom selection, Atom target, Time timestamp,
+		   WMSelectionCallback * callback, void *cdata)
+{
+	SelectionCallback *handler;
+
+	if (XGetSelectionOwner(W_VIEW_SCREEN(view)->display, selection) == None)
+		return False;
+
+	if (!XConvertSelection(W_VIEW_SCREEN(view)->display, selection, target,
+			       W_VIEW_SCREEN(view)->clipboardAtom, W_VIEW_DRAWABLE(view), timestamp)) {
+		return False;
+	}
+
+	handler = wmalloc(sizeof(SelectionCallback));
+	handler->view = view;
+	handler->selection = selection;
+	handler->target = target;
+	handler->timestamp = timestamp;
+	handler->callback = callback;
+	handler->data = cdata;
+
+	if (selCallbacks == NULL) {
+		selCallbacks = WMCreateArrayWithDestructor(4, wfree);
+	}
+
+	WMAddToArray(selCallbacks, handler);
+
+	return True;
+}

bazel/WINGs/string.c

@@ -0,0 +1,425 @@
+/*
+ * Until FreeBSD gets their act together;
+ * http://www.mail-archive.com/freebsd-hackers@freebsd.org/msg69469.html
+ */
+#if defined( FREEBSD )
+#   undef _XOPEN_SOURCE
+#endif
+
+#include "wconfig.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <ctype.h>
+#ifdef HAVE_BSD_STRING_H
+#include <bsd/string.h>
+#endif
+
+#include "WUtil.h"
+
+#define PRC_ALPHA	0
+#define PRC_BLANK	1
+#define PRC_ESCAPE	2
+#define PRC_DQUOTE	3
+#define PRC_EOS		4
+#define PRC_SQUOTE	5
+
+typedef struct {
+	short nstate;
+	short output;
+} DFA;
+
+static DFA mtable[9][6] = {
+	{{3, 1}, {0, 0}, {4, 0}, {1, 0}, {8, 0}, {6, 0}},
+	{{1, 1}, {1, 1}, {2, 0}, {3, 0}, {5, 0}, {1, 1}},
+	{{1, 1}, {1, 1}, {1, 1}, {1, 1}, {5, 0}, {1, 1}},
+	{{3, 1}, {5, 0}, {4, 0}, {1, 0}, {5, 0}, {6, 0}},
+	{{3, 1}, {3, 1}, {3, 1}, {3, 1}, {5, 0}, {3, 1}},
+	{{-1, -1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},	/* final state */
+	{{6, 1}, {6, 1}, {7, 0}, {6, 1}, {5, 0}, {3, 0}},
+	{{6, 1}, {6, 1}, {6, 1}, {6, 1}, {5, 0}, {6, 1}},
+	{{-1, -1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},	/* final state */
+};
+
+char *wtokennext(char *word, char **next)
+{
+	char *ptr;
+	char *ret, *t;
+	int state, ctype;
+
+	t = ret = wmalloc(strlen(word) + 1);
+	ptr = word;
+
+	state = 0;
+	while (1) {
+		if (*ptr == 0)
+			ctype = PRC_EOS;
+		else if (*ptr == '\\')
+			ctype = PRC_ESCAPE;
+		else if (*ptr == '"')
+			ctype = PRC_DQUOTE;
+		else if (*ptr == '\'')
+			ctype = PRC_SQUOTE;
+		else if (*ptr == ' ' || *ptr == '\t')
+			ctype = PRC_BLANK;
+		else
+			ctype = PRC_ALPHA;
+
+		if (mtable[state][ctype].output) {
+			*t = *ptr;
+			t++;
+			*t = 0;
+		}
+		state = mtable[state][ctype].nstate;
+		ptr++;
+		if (mtable[state][0].output < 0) {
+			break;
+		}
+	}
+
+	if (*ret == 0) {
+		wfree(ret);
+		ret = NULL;
+	}
+
+	if (ctype == PRC_EOS)
+		*next = NULL;
+	else
+		*next = ptr;
+
+	return ret;
+}
+
+/* separate a string in tokens, taking " and ' into account */
+void wtokensplit(char *command, char ***argv, int *argc)
+{
+	char *token, *line;
+	int count;
+
+	count = 0;
+	line = command;
+	do {
+		token = wtokennext(line, &line);
+		if (token) {
+			if (count == 0)
+				*argv = wmalloc(sizeof(**argv));
+			else
+				*argv = wrealloc(*argv, (count + 1) * sizeof(**argv));
+			(*argv)[count++] = token;
+		}
+	} while (token != NULL && line != NULL);
+
+	*argc = count;
+}
+
+char *wtokenjoin(char **list, int count)
+{
+	int i, j;
+	char *flat_string, *wspace;
+
+	j = 0;
+	for (i = 0; i < count; i++) {
+		if (list[i] != NULL && list[i][0] != 0) {
+			j += strlen(list[i]);
+			if (strpbrk(list[i], " \t"))
+				j += 2;
+		}
+	}
+
+	flat_string = wmalloc(j + count + 1);
+
+	for (i = 0; i < count; i++) {
+		if (list[i] != NULL && list[i][0] != 0) {
+			if (i > 0 &&
+			    wstrlcat(flat_string, " ", j + count + 1) >= j + count + 1)
+					goto error;
+
+			wspace = strpbrk(list[i], " \t");
+
+			if (wspace &&
+			    wstrlcat(flat_string, "\"", j + count + 1) >= j + count + 1)
+					goto error;
+
+			if (wstrlcat(flat_string, list[i], j + count + 1) >= j + count + 1)
+				goto error;
+
+			if (wspace &&
+			    wstrlcat(flat_string, "\"", j + count + 1) >= j + count + 1)
+					goto error;
+		}
+	}
+
+	return flat_string;
+
+error:
+	wfree(flat_string);
+
+	return NULL;
+}
+
+void wtokenfree(char **tokens, int count)
+{
+	while (count--)
+		wfree(tokens[count]);
+	wfree(tokens);
+}
+
+char *wtrimspace(const char *s)
+{
+	const char *t;
+
+	if (s == NULL)
+		return NULL;
+
+	while (isspace(*s) && *s)
+		s++;
+	t = s + strlen(s) - 1;
+	while (t > s && isspace(*t))
+		t--;
+
+	return wstrndup(s, t - s + 1);
+}
+
+char *wstrdup(const char *str)
+{
+	assert(str != NULL);
+
+	return strcpy(wmalloc(strlen(str) + 1), str);
+}
+
+char *wstrndup(const char *str, size_t len)
+{
+	char *copy;
+
+	assert(str != NULL);
+
+	len = WMIN(len, strlen(str));
+	copy = strncpy(wmalloc(len + 1), str, len);
+	copy[len] = 0;
+
+	return copy;
+}
+
+char *wstrconcat(const char *str1, const char *str2)
+{
+	char *str;
+	size_t slen, slen1;
+
+	if (!str1 && str2)
+		return wstrdup(str2);
+	else if (str1 && !str2)
+		return wstrdup(str1);
+	else if (!str1 && !str2)
+		return NULL;
+
+	slen1 = strlen(str1);
+	slen = slen1 + strlen(str2) + 1;
+	str = wmalloc(slen);
+	strcpy(str, str1);
+	strcpy(str + slen1, str2);
+
+	return str;
+}
+
+char *wstrappend(char *dst, const char *src)
+{
+	size_t slen;
+
+	if (!src || *src == 0)
+		return dst;
+	else if (!dst)
+		return wstrdup(src);
+
+	slen = strlen(dst) + strlen(src) + 1;
+	dst = wrealloc(dst, slen);
+	strcat(dst, src);
+
+	return dst;
+}
+
+
+#ifdef HAVE_STRLCAT
+size_t
+wstrlcat(char *dst, const char *src, size_t siz)
+{
+	return strlcat(dst, src, siz);
+}
+#else
+/*	$OpenBSD: strlcat.c,v 1.13 2005/08/08 08:05:37 espie Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+size_t
+wstrlcat(char *dst, const char *src, size_t siz)
+{
+	char *d = dst;
+	const char *s = src;
+	size_t n = siz;
+	size_t dlen;
+
+	/* Find the end of dst and adjust bytes left but don't go past end */
+	while (n-- != 0 && *d != '\0')
+		d++;
+	dlen = d - dst;
+	n = siz - dlen;
+
+	if (n == 0)
+		return(dlen + strlen(s));
+	while (*s != '\0') {
+		if (n != 1) {
+			*d++ = *s;
+			n--;
+		}
+		s++;
+	}
+	*d = '\0';
+
+	return(dlen + (s - src));	/* count does not include NUL */
+}
+#endif /* HAVE_STRLCAT */
+
+#ifdef HAVE_STRLCPY
+size_t
+wstrlcpy(char *dst, const char *src, size_t siz)
+{
+	return strlcpy(dst, src, siz);
+}
+#else
+
+/*	$OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t
+wstrlcpy(char *dst, const char *src, size_t siz)
+{
+	char *d = dst;
+	const char *s = src;
+	size_t n = siz;
+
+	/* Copy as many bytes as will fit */
+	if (n != 0) {
+		while (--n != 0) {
+			if ((*d++ = *s++) == '\0')
+				break;
+		}
+	}
+
+	/* Not enough room in dst, add NUL and traverse rest of src */
+	if (n == 0) {
+		if (siz != 0)
+			*d = '\0';		/* NUL-terminate dst */
+		while (*s++)
+			;
+	}
+
+	return(s - src - 1);	/* count does not include NUL */
+}
+#endif /* HAVE_STRLCPY */
+
+/* transform `s' so that the result is safe to pass to the shell as an argument.
+ * returns a newly allocated string.
+ * with very heavy inspirations from NetBSD's shquote(3).
+ */
+char *wshellquote(const char *s)
+{
+	char *p, *r, *last, *ret;
+	size_t slen;
+	int needs_quoting;
+
+	if (!s)
+		return NULL;
+
+	needs_quoting = !*s;			/* the empty string does need quoting */
+
+	/* do not quote if consists only of the following characters */
+	for (p = (char *)s; *p && !needs_quoting; p++) {
+		needs_quoting = !(isalnum(*p) || (*p == '+') || (*p == '/') ||
+				 (*p == '.') || (*p == ',') || (*p == '-'));
+	}
+
+	if (!needs_quoting)
+		return wstrdup(s);
+
+	for (slen = 0, p = (char *)s; *p; p++)		/* count space needed (worst case) */
+		slen += *p == '\'' ? 4 : 1;		/* every single ' becomes ''\' */
+
+	slen += 2 /* leading + trailing "'" */ + 1 /* NULL */;
+
+	ret = r = wmalloc(slen);
+	p = (char *)s;
+	last = p;
+
+	if (*p != '\'')					/* if string doesn't already begin with "'" */
+		*r++ ='\'';				/* start putting it in quotes */
+
+	while (*p) {
+		last = p;
+		if (*p == '\'') {			/* turn each ' into ''\' */
+			if (p != s)			/* except if it's the first ', in which case */
+				*r++ = '\'';		/* only escape it */
+			*r++ = '\\';
+			*r++ = '\'';
+			while (*++p && *p == '\'') {	/* keep turning each consecutive 's into \' */
+				*r++ = '\\';
+				*r++ = '\'';
+			}
+			if (*p)				/* if more input follows, terminate */
+				*r++ = '\'';		/* what we have so far */
+		} else {
+			*r++ = *p++;
+		}
+	}
+
+	if (*last != '\'')				/* if the last one isn't already a ' */
+		*r++ = '\'';				/* terminate the whole shebang */
+
+	*r = '\0';
+
+	return ret;					/* technically, we lose (but not leak) a couple of */
+							/* bytes (twice the number of consecutive 's in the */
+							/* input or so), but since these are relatively rare */
+							/* and short-lived strings, not sure if a trip to */
+							/* wstrdup+wfree worths the gain. */
+}

bazel/WINGs/tree.c

@@ -0,0 +1,255 @@
+
+#include <string.h>
+
+#include "WUtil.h"
+
+typedef struct W_TreeNode {
+	void *data;
+
+	/*unsigned int uflags:16; */
+
+	WMArray *leaves;
+
+	int depth;
+
+	struct W_TreeNode *parent;
+
+	WMFreeDataProc *destructor;
+} W_TreeNode;
+
+static void destroyNode(void *data)
+{
+	WMTreeNode *aNode = (WMTreeNode *) data;
+
+	if (aNode->destructor) {
+		(*aNode->destructor) (aNode->data);
+	}
+	if (aNode->leaves) {
+		WMFreeArray(aNode->leaves);
+	}
+	wfree(aNode);
+}
+
+WMTreeNode *WMCreateTreeNode(void *data)
+{
+	return WMCreateTreeNodeWithDestructor(data, NULL);
+}
+
+WMTreeNode *WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc * destructor)
+{
+	WMTreeNode *aNode;
+
+	aNode = (WMTreeNode *) wmalloc(sizeof(W_TreeNode));
+	aNode->destructor = destructor;
+	aNode->data = data;
+	aNode->parent = NULL;
+	aNode->depth = 0;
+	aNode->leaves = NULL;
+	/*aNode->leaves = WMCreateArrayWithDestructor(1, destroyNode); */
+
+	return aNode;
+}
+
+WMTreeNode *WMInsertItemInTree(WMTreeNode * parent, int index, void *item)
+{
+	WMTreeNode *aNode;
+
+	wassertrv(parent != NULL, NULL);
+
+	aNode = WMCreateTreeNodeWithDestructor(item, parent->destructor);
+	aNode->parent = parent;
+	aNode->depth = parent->depth + 1;
+	if (!parent->leaves) {
+		parent->leaves = WMCreateArrayWithDestructor(1, destroyNode);
+	}
+	if (index < 0) {
+		WMAddToArray(parent->leaves, aNode);
+	} else {
+		WMInsertInArray(parent->leaves, index, aNode);
+	}
+
+	return aNode;
+}
+
+static void updateNodeDepth(WMTreeNode * aNode, int depth)
+{
+	int i;
+
+	aNode->depth = depth;
+
+	if (aNode->leaves) {
+		for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
+			updateNodeDepth(WMGetFromArray(aNode->leaves, i), depth + 1);
+		}
+	}
+}
+
+WMTreeNode *WMInsertNodeInTree(WMTreeNode * parent, int index, WMTreeNode * aNode)
+{
+	wassertrv(parent != NULL, NULL);
+	wassertrv(aNode != NULL, NULL);
+
+	aNode->parent = parent;
+	updateNodeDepth(aNode, parent->depth + 1);
+	if (!parent->leaves) {
+		parent->leaves = WMCreateArrayWithDestructor(1, destroyNode);
+	}
+	if (index < 0) {
+		WMAddToArray(parent->leaves, aNode);
+	} else {
+		WMInsertInArray(parent->leaves, index, aNode);
+	}
+
+	return aNode;
+}
+
+void WMDestroyTreeNode(WMTreeNode * aNode)
+{
+	wassertr(aNode != NULL);
+
+	if (aNode->parent && aNode->parent->leaves) {
+		WMRemoveFromArray(aNode->parent->leaves, aNode);
+	} else {
+		destroyNode(aNode);
+	}
+}
+
+void WMDeleteLeafForTreeNode(WMTreeNode * aNode, int index)
+{
+	wassertr(aNode != NULL);
+	wassertr(aNode->leaves != NULL);
+
+	WMDeleteFromArray(aNode->leaves, index);
+}
+
+static int sameData(const void *item, const void *data)
+{
+	return (((WMTreeNode *) item)->data == data);
+}
+
+void WMRemoveLeafForTreeNode(WMTreeNode * aNode, void *leaf)
+{
+	int index;
+
+	wassertr(aNode != NULL);
+	wassertr(aNode->leaves != NULL);
+
+	index = WMFindInArray(aNode->leaves, sameData, leaf);
+	if (index != WANotFound) {
+		WMDeleteFromArray(aNode->leaves, index);
+	}
+}
+
+void *WMReplaceDataForTreeNode(WMTreeNode * aNode, void *newData)
+{
+	void *old;
+
+	wassertrv(aNode != NULL, NULL);
+
+	old = aNode->data;
+	aNode->data = newData;
+
+	return old;
+}
+
+void *WMGetDataForTreeNode(WMTreeNode * aNode)
+{
+	return aNode->data;
+}
+
+int WMGetTreeNodeDepth(WMTreeNode * aNode)
+{
+	return aNode->depth;
+}
+
+WMTreeNode *WMGetParentForTreeNode(WMTreeNode * aNode)
+{
+	return aNode->parent;
+}
+
+void WMSortLeavesForTreeNode(WMTreeNode * aNode, WMCompareDataProc * comparer)
+{
+	wassertr(aNode != NULL);
+
+	if (aNode->leaves) {
+		WMSortArray(aNode->leaves, comparer);
+	}
+}
+
+static void sortLeavesForNode(WMTreeNode * aNode, WMCompareDataProc * comparer)
+{
+	int i;
+
+	if (!aNode->leaves)
+		return;
+
+	WMSortArray(aNode->leaves, comparer);
+	for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
+		sortLeavesForNode(WMGetFromArray(aNode->leaves, i), comparer);
+	}
+}
+
+void WMSortTree(WMTreeNode * aNode, WMCompareDataProc * comparer)
+{
+	wassertr(aNode != NULL);
+
+	sortLeavesForNode(aNode, comparer);
+}
+
+static WMTreeNode *findNodeInTree(WMTreeNode * aNode, WMMatchDataProc * match, void *cdata, int limit)
+{
+	if (match == NULL && aNode->data == cdata)
+		return aNode;
+	else if (match && (*match) (aNode->data, cdata))
+		return aNode;
+
+	if (aNode->leaves && limit != 0) {
+		WMTreeNode *leaf;
+		int i;
+
+		for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
+			leaf = findNodeInTree(WMGetFromArray(aNode->leaves, i),
+					      match, cdata, limit > 0 ? limit - 1 : limit);
+			if (leaf)
+				return leaf;
+		}
+	}
+
+	return NULL;
+}
+
+WMTreeNode *WMFindInTree(WMTreeNode * aTree, WMMatchDataProc * match, void *cdata)
+{
+	wassertrv(aTree != NULL, NULL);
+
+	return findNodeInTree(aTree, match, cdata, -1);
+}
+
+WMTreeNode *WMFindInTreeWithDepthLimit(WMTreeNode * aTree, WMMatchDataProc * match, void *cdata, int limit)
+{
+	wassertrv(aTree != NULL, NULL);
+	wassertrv(limit >= 0, NULL);
+
+	return findNodeInTree(aTree, match, cdata, limit);
+}
+
+void WMTreeWalk(WMTreeNode * aNode, WMTreeWalkProc * walk, void *data, Bool DepthFirst)
+{
+	int i;
+	WMTreeNode *leaf;
+
+	wassertr(aNode != NULL);
+
+	if (DepthFirst)
+		(*walk)(aNode, data);
+
+	if (aNode->leaves) {
+		for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
+			leaf = (WMTreeNode *)WMGetFromArray(aNode->leaves, i);
+			WMTreeWalk(leaf, walk, data, DepthFirst);
+		}
+	}
+
+	if (!DepthFirst)
+		(*walk)(aNode, data);
+}

bazel/WINGs/userdefaults.c

@@ -0,0 +1,641 @@
+
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <stdio.h>
+#include <assert.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "WINGs/wconfig.h"
+
+#include "WINGs/WINGs.h"
+#include "WINGs/WINGsP.h"
+#include "userdefaults.h"
+
+
+typedef struct W_UserDefaults {
+	WMPropList *defaults;
+
+	WMPropList *appDomain;
+
+	WMPropList *searchListArray;
+	WMPropList **searchList;	/* cache for searchListArray */
+
+	char dirty;
+
+	char dontSync;
+
+	char *path;		/* where is db located */
+
+	time_t timestamp;	/* last modification time */
+
+	struct W_UserDefaults *next;
+
+} UserDefaults;
+
+static UserDefaults *sharedUserDefaults = NULL;
+
+char *WMUserDefaultsDidChangeNotification = "WMUserDefaultsDidChangeNotification";
+
+static void synchronizeUserDefaults(void *foo);
+
+#ifndef HAVE_INOTIFY
+/* Check defaults database for changes every this many milliseconds */
+/* XXX: this is shared with src/ stuff, put it in some common header */
+#define UD_SYNC_INTERVAL	2000
+#endif
+
+const char *wusergnusteppath(void)
+{
+	static const char subdir[] = "/" GSUSER_SUBDIR;
+	static char *path = NULL;
+	char *gspath;
+	const char *h;
+	int pathlen;
+
+	if (path)
+		/* Value have been already computed, re-use it */
+		return path;
+
+	gspath = GETENV("WMAKER_USER_ROOT");
+	if (gspath) {
+		gspath = wexpandpath(gspath);
+		if (gspath) {
+			path = gspath;
+			return path;
+		}
+		wwarning(_("variable WMAKER_USER_ROOT defined with invalid path, not used"));
+	}
+
+	h = wgethomedir();
+	if (!h)
+		return NULL;
+
+	pathlen = strlen(h);
+	path = wmalloc(pathlen + sizeof(subdir));
+	strcpy(path, h);
+	strcpy(path + pathlen, subdir);
+
+	return path;
+}
+
+const char *wuserdatapath(void)
+{
+	static char *path = NULL;
+
+	if (path)
+		/* Value have been already computed, re-use it */
+		return path;
+
+	path = wstrconcat(wusergnusteppath(), "/" USERDATA_SUBDIR);
+
+	return path;
+}
+
+char *wdefaultspathfordomain(const char *domain)
+{
+	char *path;
+	const char *gspath;
+	size_t slen;
+
+	gspath = wusergnusteppath();
+	slen = strlen(gspath) + strlen("/" DEFAULTS_SUBDIR "/") + strlen(domain) + 1;
+	path = wmalloc(slen);
+
+	strcpy(path, gspath);
+	strcat(path, "/" DEFAULTS_SUBDIR "/");
+	strcat(path, domain);
+
+	return path;
+}
+
+/* XXX: doesn't quite belong to *user*defaults.c */
+char *wglobaldefaultspathfordomain(const char *domain)
+{
+	return wstrconcat(PKGCONFDIR "/", domain);
+}
+
+void w_save_defaults_changes(void)
+{
+	if (WMApplication.applicationName == NULL) {
+		/*
+		 * This means that the user has properly exited by calling the
+		 * function 'WMReleaseApplication' (which has already called us)
+		 * but we're being called again by the fallback 'atexit' method
+		 * (the legacy way of saving changes on exit which is kept for
+		 * application that would forget to call 'WMReleaseApplication')
+		 */
+		return;
+	}
+
+	/* save the user defaults databases */
+	synchronizeUserDefaults(NULL);
+}
+
+/* set to save changes in defaults when program is exited */
+static void registerSaveOnExit(void)
+{
+	static Bool registeredSaveOnExit = False;
+
+	if (!registeredSaveOnExit) {
+		atexit(w_save_defaults_changes);
+		registeredSaveOnExit = True;
+	}
+}
+
+static void synchronizeUserDefaults(void *foo)
+{
+	UserDefaults *database = sharedUserDefaults;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) foo;
+
+	while (database) {
+		if (!database->dontSync)
+			WMSynchronizeUserDefaults(database);
+		database = database->next;
+	}
+}
+
+#ifndef HAVE_INOTIFY
+static void addSynchronizeTimerHandler(void)
+{
+	static Bool initialized = False;
+
+	if (!initialized) {
+		WMAddPersistentTimerHandler(UD_SYNC_INTERVAL,
+		    synchronizeUserDefaults, NULL);
+		initialized = True;
+	}
+}
+#endif
+
+void WMEnableUDPeriodicSynchronization(WMUserDefaults * database, Bool enable)
+{
+	database->dontSync = !enable;
+}
+
+void WMSynchronizeUserDefaults(WMUserDefaults * database)
+{
+	Bool fileIsNewer = False, release = False, notify = False;
+	WMPropList *plF, *key;
+	char *path;
+	struct stat stbuf;
+
+	if (!database->path) {
+		path = wdefaultspathfordomain(WMGetApplicationName());
+		release = True;
+	} else {
+		path = database->path;
+	}
+
+	if (stat(path, &stbuf) >= 0 && stbuf.st_mtime > database->timestamp)
+		fileIsNewer = True;
+
+	if (database->appDomain && (database->dirty || fileIsNewer)) {
+		if (database->dirty && fileIsNewer) {
+			plF = WMReadPropListFromFile(path);
+			if (plF) {
+				plF = WMMergePLDictionaries(plF, database->appDomain, False);
+				WMReleasePropList(database->appDomain);
+				database->appDomain = plF;
+				key = database->searchList[0];
+				WMPutInPLDictionary(database->defaults, key, plF);
+				notify = True;
+			} else {
+				/* something happened with the file. just overwrite it */
+				wwarning(_("cannot read domain from file '%s' when syncing"), path);
+				WMWritePropListToFile(database->appDomain, path);
+			}
+		} else if (database->dirty) {
+			WMWritePropListToFile(database->appDomain, path);
+		} else if (fileIsNewer) {
+			plF = WMReadPropListFromFile(path);
+			if (plF) {
+				WMReleasePropList(database->appDomain);
+				database->appDomain = plF;
+				key = database->searchList[0];
+				WMPutInPLDictionary(database->defaults, key, plF);
+				notify = True;
+			} else {
+				/* something happened with the file. just overwrite it */
+				wwarning(_("cannot read domain from file '%s' when syncing"), path);
+				WMWritePropListToFile(database->appDomain, path);
+			}
+		}
+
+		database->dirty = 0;
+
+		if (stat(path, &stbuf) >= 0)
+			database->timestamp = stbuf.st_mtime;
+
+		if (notify) {
+			WMPostNotificationName(WMUserDefaultsDidChangeNotification, database, NULL);
+		}
+	}
+
+	if (release)
+		wfree(path);
+
+}
+
+void WMSaveUserDefaults(WMUserDefaults * database)
+{
+	if (database->appDomain) {
+		struct stat stbuf;
+		char *path;
+		Bool release = False;
+
+		if (!database->path) {
+			path = wdefaultspathfordomain(WMGetApplicationName());
+			release = True;
+		} else {
+			path = database->path;
+		}
+		WMWritePropListToFile(database->appDomain, path);
+		database->dirty = 0;
+		if (stat(path, &stbuf) >= 0)
+			database->timestamp = stbuf.st_mtime;
+		if (release)
+			wfree(path);
+	}
+}
+
+WMUserDefaults *WMGetStandardUserDefaults(void)
+{
+	WMUserDefaults *defaults;
+	WMPropList *domain;
+	WMPropList *key;
+	struct stat stbuf;
+	char *path;
+	int i;
+
+	if (sharedUserDefaults) {
+		defaults = sharedUserDefaults;
+		while (defaults) {
+			/* path == NULL only for StandardUserDefaults db */
+			if (defaults->path == NULL)
+				return defaults;
+			defaults = defaults->next;
+		}
+	}
+
+	/* we didn't found the database we are looking for. Go read it. XXX: wtf? */
+	defaults = wmalloc(sizeof(WMUserDefaults));
+	defaults->defaults = WMCreatePLDictionary(NULL, NULL);
+	defaults->searchList = wmalloc(sizeof(WMPropList *) * 3);
+
+	/* application domain */
+	key = WMCreatePLString(WMGetApplicationName());
+	defaults->searchList[0] = key;
+
+	/* temporary kluge. wmaker handles synchronization itself */
+	if (strcmp(WMGetApplicationName(), "WindowMaker") == 0) {
+		defaults->dontSync = 1;
+	}
+
+	path = wdefaultspathfordomain(WMGetFromPLString(key));
+
+	if (stat(path, &stbuf) >= 0)
+		defaults->timestamp = stbuf.st_mtime;
+
+	domain = WMReadPropListFromFile(path);
+
+	if (!domain)
+		domain = WMCreatePLDictionary(NULL, NULL);
+
+	wfree(path);
+
+	defaults->appDomain = domain;
+
+	if (domain)
+		WMPutInPLDictionary(defaults->defaults, key, domain);
+
+	/* global domain */
+	key = WMCreatePLString("WMGLOBAL");
+	defaults->searchList[1] = key;
+
+	path = wdefaultspathfordomain(WMGetFromPLString(key));
+
+	domain = WMReadPropListFromFile(path);
+
+	wfree(path);
+
+	if (!domain)
+		domain = WMCreatePLDictionary(NULL, NULL);
+
+	if (domain)
+		WMPutInPLDictionary(defaults->defaults, key, domain);
+
+	/* terminate list */
+	defaults->searchList[2] = NULL;
+
+	defaults->searchListArray = WMCreatePLArray(NULL, NULL);
+
+	i = 0;
+	while (defaults->searchList[i]) {
+		WMAddToPLArray(defaults->searchListArray, defaults->searchList[i]);
+		i++;
+	}
+
+	if (sharedUserDefaults)
+		defaults->next = sharedUserDefaults;
+	sharedUserDefaults = defaults;
+
+#ifndef HAVE_INOTIFY
+	addSynchronizeTimerHandler();
+#endif
+	registerSaveOnExit();
+
+	return defaults;
+}
+
+WMUserDefaults *WMGetDefaultsFromPath(const char *path)
+{
+	WMUserDefaults *defaults;
+	WMPropList *domain;
+	WMPropList *key;
+	struct stat stbuf;
+	const char *name;
+	int i;
+
+	assert(path != NULL);
+
+	if (sharedUserDefaults) {
+		defaults = sharedUserDefaults;
+		while (defaults) {
+			if (defaults->path && strcmp(defaults->path, path) == 0)
+				return defaults;
+			defaults = defaults->next;
+		}
+	}
+
+	/* we didn't found the database we are looking for. Go read it. XXX wtf? */
+	defaults = wmalloc(sizeof(WMUserDefaults));
+	defaults->defaults = WMCreatePLDictionary(NULL, NULL);
+	defaults->searchList = wmalloc(sizeof(WMPropList *) * 2);
+
+	/* the domain we want, go in the first position */
+	name = strrchr(path, '/');
+	if (!name)
+		name = path;
+	else
+		name++;
+
+	key = WMCreatePLString(name);
+	defaults->searchList[0] = key;
+
+	if (stat(path, &stbuf) >= 0)
+		defaults->timestamp = stbuf.st_mtime;
+
+	domain = WMReadPropListFromFile(path);
+
+	if (!domain)
+		domain = WMCreatePLDictionary(NULL, NULL);
+
+	defaults->path = wstrdup(path);
+
+	defaults->appDomain = domain;
+
+	if (domain)
+		WMPutInPLDictionary(defaults->defaults, key, domain);
+
+	/* terminate list */
+	defaults->searchList[1] = NULL;
+
+	defaults->searchListArray = WMCreatePLArray(NULL, NULL);
+
+	i = 0;
+	while (defaults->searchList[i]) {
+		WMAddToPLArray(defaults->searchListArray, defaults->searchList[i]);
+		i++;
+	}
+
+	if (sharedUserDefaults)
+		defaults->next = sharedUserDefaults;
+	sharedUserDefaults = defaults;
+
+#ifndef HAVE_INOTIFY
+	addSynchronizeTimerHandler();
+#endif
+	registerSaveOnExit();
+
+	return defaults;
+}
+
+/* Returns a WMPropList array with all keys in the user defaults database.
+ * Free the array with WMReleasePropList() when no longer needed,
+ * but do not free the elements of the array! They're just references. */
+WMPropList *WMGetUDKeys(WMUserDefaults * database)
+{
+	return WMGetPLDictionaryKeys(database->appDomain);
+}
+
+WMPropList *WMGetUDObjectForKey(WMUserDefaults * database, const char *defaultName)
+{
+	WMPropList *domainName, *domain;
+	WMPropList *object = NULL;
+	WMPropList *key = WMCreatePLString(defaultName);
+	int i = 0;
+
+	while (database->searchList[i] && !object) {
+		domainName = database->searchList[i];
+		domain = WMGetFromPLDictionary(database->defaults, domainName);
+		if (domain) {
+			object = WMGetFromPLDictionary(domain, key);
+		}
+		i++;
+	}
+	WMReleasePropList(key);
+
+	return object;
+}
+
+void WMSetUDObjectForKey(WMUserDefaults * database, WMPropList * object, const char *defaultName)
+{
+	WMPropList *key = WMCreatePLString(defaultName);
+
+	database->dirty = 1;
+
+	WMPutInPLDictionary(database->appDomain, key, object);
+	WMReleasePropList(key);
+}
+
+void WMRemoveUDObjectForKey(WMUserDefaults * database, const char *defaultName)
+{
+	WMPropList *key = WMCreatePLString(defaultName);
+
+	database->dirty = 1;
+
+	WMRemoveFromPLDictionary(database->appDomain, key);
+
+	WMReleasePropList(key);
+}
+
+char *WMGetUDStringForKey(WMUserDefaults * database, const char *defaultName)
+{
+	WMPropList *val;
+
+	val = WMGetUDObjectForKey(database, defaultName);
+
+	if (!val)
+		return NULL;
+
+	if (!WMIsPLString(val))
+		return NULL;
+
+	return WMGetFromPLString(val);
+}
+
+int WMGetUDIntegerForKey(WMUserDefaults * database, const char *defaultName)
+{
+	WMPropList *val;
+	char *str;
+	int value;
+
+	val = WMGetUDObjectForKey(database, defaultName);
+
+	if (!val)
+		return 0;
+
+	if (!WMIsPLString(val))
+		return 0;
+
+	str = WMGetFromPLString(val);
+	if (!str)
+		return 0;
+
+	if (sscanf(str, "%i", &value) != 1)
+		return 0;
+
+	return value;
+}
+
+float WMGetUDFloatForKey(WMUserDefaults * database, const char *defaultName)
+{
+	WMPropList *val;
+	char *str;
+	float value;
+
+	val = WMGetUDObjectForKey(database, defaultName);
+
+	if (!val || !WMIsPLString(val))
+		return 0.0;
+
+	if (!(str = WMGetFromPLString(val)))
+		return 0.0;
+
+	if (sscanf(str, "%f", &value) != 1)
+		return 0.0;
+
+	return value;
+}
+
+Bool WMGetUDBoolForKey(WMUserDefaults * database, const char *defaultName)
+{
+	WMPropList *val;
+	int value;
+	char *str;
+
+	val = WMGetUDObjectForKey(database, defaultName);
+
+	if (!val)
+		return False;
+
+	if (!WMIsPLString(val))
+		return False;
+
+	str = WMGetFromPLString(val);
+	if (!str)
+		return False;
+
+	if (sscanf(str, "%i", &value) == 1 && value != 0)
+		return True;
+
+	if (strcasecmp(str, "YES") == 0)
+		return True;
+
+	if (strcasecmp(str, "Y") == 0)
+		return True;
+
+	return False;
+}
+
+void WMSetUDIntegerForKey(WMUserDefaults * database, int value, const char *defaultName)
+{
+	WMPropList *object;
+	char buffer[128];
+
+	sprintf(buffer, "%i", value);
+	object = WMCreatePLString(buffer);
+
+	WMSetUDObjectForKey(database, object, defaultName);
+	WMReleasePropList(object);
+}
+
+void WMSetUDStringForKey(WMUserDefaults * database, const char *value, const char *defaultName)
+{
+	WMPropList *object;
+
+	object = WMCreatePLString(value);
+
+	WMSetUDObjectForKey(database, object, defaultName);
+	WMReleasePropList(object);
+}
+
+void WMSetUDFloatForKey(WMUserDefaults * database, float value, const char *defaultName)
+{
+	WMPropList *object;
+	char buffer[128];
+
+	sprintf(buffer, "%f", (double)value);
+	object = WMCreatePLString(buffer);
+
+	WMSetUDObjectForKey(database, object, defaultName);
+	WMReleasePropList(object);
+}
+
+void WMSetUDBoolForKey(WMUserDefaults * database, Bool value, const char *defaultName)
+{
+	static WMPropList *yes = NULL, *no = NULL;
+
+	if (!yes) {
+		yes = WMCreatePLString("YES");
+		no = WMCreatePLString("NO");
+	}
+
+	WMSetUDObjectForKey(database, value ? yes : no, defaultName);
+}
+
+WMPropList *WMGetUDSearchList(WMUserDefaults * database)
+{
+	return database->searchListArray;
+}
+
+void WMSetUDSearchList(WMUserDefaults * database, WMPropList * list)
+{
+	int i, c;
+
+	if (database->searchList) {
+		i = 0;
+		while (database->searchList[i]) {
+			WMReleasePropList(database->searchList[i]);
+			i++;
+		}
+		wfree(database->searchList);
+	}
+	if (database->searchListArray) {
+		WMReleasePropList(database->searchListArray);
+	}
+
+	c = WMGetPropListItemCount(list);
+	database->searchList = wmalloc(sizeof(WMPropList *) * (c + 1));
+
+	for (i = 0; i < c; i++) {
+		database->searchList[i] = WMGetFromPLArray(list, i);
+	}
+	database->searchList[c] = NULL;
+
+	database->searchListArray = WMDeepCopyPropList(list);
+}

bazel/WINGs/userdefaults.h

@@ -0,0 +1,34 @@
+/* WUtil / userdefaults.h
+ *
+ *  Copyright (c) 2014 Window Maker Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef WUTIL_USERDEFAULTS_H
+#define WUTIL_USERDEFAULTS_H
+
+/*
+ * This file is not part of WUtil public API
+ *
+ * It defines internal things for the user configuration handling functions
+ */
+
+
+/* Save user configuration, to be used when application exits only */
+void w_save_defaults_changes(void);
+
+
+#endif /* WUTIL_USERDEFAULTS_H */

bazel/WINGs/usleep.c

@@ -0,0 +1,26 @@
+
+#include <errno.h>
+#include <time.h>
+
+#include "WUtil.h"
+#include "wconfig.h"
+
+void wusleep(unsigned int usec)
+{
+	struct timespec tm;
+
+	/* An arbitrary limit of 10 minutes -- in WM, if
+	 * somethings wants to sleep anything even close to
+	 * this, it's most likely an error.
+	 */
+	if (usec > 600000000)
+		return;
+
+	tm.tv_sec = usec / 1000000;
+	tm.tv_nsec = (usec % 1000000) * 1000;
+
+	while (nanosleep(&tm, &tm) == -1 && errno == EINTR)
+		;
+
+}
+

bazel/WINGs/wapplication.c

@@ -0,0 +1,216 @@
+
+#include <unistd.h>
+#include <X11/Xlocale.h>
+
+#include "WINGs/WINGsP.h"
+#include "WINGs/wconfig.h"
+#include "userdefaults.h"
+
+
+struct W_Application WMApplication;
+
+const char *_WINGS_progname = NULL;
+
+Bool W_ApplicationInitialized(void)
+{
+	return _WINGS_progname != NULL;
+}
+
+void WMInitializeApplication(const char *applicationName, int *argc, char **argv)
+{
+	int i;
+
+	assert(argc != NULL);
+	assert(argv != NULL);
+	assert(applicationName != NULL);
+
+	setlocale(LC_ALL, "");
+
+#ifdef I18N
+	if (getenv("NLSPATH"))
+		bindtextdomain("WINGs", getenv("NLSPATH"));
+	else
+		bindtextdomain("WINGs", LOCALEDIR);
+	bind_textdomain_codeset("WINGs", "UTF-8");
+#endif
+
+	_WINGS_progname = argv[0];
+
+	WMApplication.applicationName = wstrdup(applicationName);
+	WMApplication.argc = *argc;
+
+	WMApplication.argv = wmalloc((*argc + 1) * sizeof(char *));
+	for (i = 0; i < *argc; i++) {
+		WMApplication.argv[i] = wstrdup(argv[i]);
+	}
+	WMApplication.argv[i] = NULL;
+
+	/* initialize notification center */
+	W_InitNotificationCenter();
+}
+
+void WMReleaseApplication(void) {
+	int i;
+
+	/*
+	 * We save the configuration on exit, this used to be handled
+	 * through an 'atexit' registered function but if application
+	 * properly calls WMReleaseApplication then the info to that
+	 * will have been freed by us.
+	 */
+	w_save_defaults_changes();
+
+	W_ReleaseNotificationCenter();
+
+	if (WMApplication.applicationName) {
+		wfree(WMApplication.applicationName);
+		WMApplication.applicationName = NULL;
+	}
+
+	if (WMApplication.argv) {
+		for (i = 0; i < WMApplication.argc; i++)
+			wfree(WMApplication.argv[i]);
+
+		wfree(WMApplication.argv);
+		WMApplication.argv = NULL;
+	}
+}
+
+void WMSetResourcePath(const char *path)
+{
+	if (WMApplication.resourcePath)
+		wfree(WMApplication.resourcePath);
+	WMApplication.resourcePath = wstrdup(path);
+}
+
+char *WMGetApplicationName(void)
+{
+	return WMApplication.applicationName;
+}
+
+static char *checkFile(const char *path, const char *folder, const char *ext, const char *resource)
+{
+	char *ret;
+	int extralen;
+	size_t slen;
+
+	if (!path || !resource)
+		return NULL;
+
+	extralen = (ext ? strlen(ext) + 1 : 0) + (folder ? strlen(folder) + 1 : 0) + 1;
+	slen = strlen(path) + strlen(resource) + 1 + extralen;
+	ret = wmalloc(slen);
+
+	if (wstrlcpy(ret, path, slen) >= slen)
+		goto error;
+
+	if (folder &&
+		(wstrlcat(ret, "/", slen) >= slen ||
+		 wstrlcat(ret, folder, slen) >= slen))
+			goto error;
+
+	if (ext &&
+		(wstrlcat(ret, "/", slen) >= slen ||
+		 wstrlcat(ret, ext, slen) >= slen))
+			goto error;
+
+	if (wstrlcat(ret, "/", slen) >= slen ||
+	    wstrlcat(ret, resource, slen) >= slen)
+		goto error;
+
+	if (access(ret, F_OK) != 0)
+		goto error;
+
+	return ret;
+
+error:
+	if (ret)
+		wfree(ret);
+	return NULL;
+}
+
+char *WMPathForResourceOfType(const char *resource, const char *ext)
+{
+	const char *gslocapps, *gssysapps, *gsuserapps;
+	char *path, *appdir;
+	char buffer[PATH_MAX];
+	size_t slen;
+
+	path = appdir = NULL;
+
+	/*
+	 * Paths are searched in this order:
+	 * - resourcePath/ext
+	 * - dirname(argv[0])/ext
+	 * - WMAKER_USER_ROOT/Applications/ApplicationName.app/ext
+	 * - GNUSTEP_USER_APPS/ApplicationName.app/ext
+	 * - GNUSTEP_LOCAL_APPS/ApplicationName.app/ext
+	 * - /usr/local/lib/GNUstep/Applications/ApplicationName.app/ext
+	 * - GNUSTEP_SYSTEM_APPS/ApplicationName.app/ext
+	 * - /usr/lib/GNUstep/Applications/ApplicationName.app/ext
+	 */
+
+	if (WMApplication.resourcePath) {
+		path = checkFile(WMApplication.resourcePath, NULL, ext, resource);
+		if (path)
+			goto out;
+	}
+
+	if (WMApplication.argv[0]) {
+		char *ptr_slash;
+
+		ptr_slash = strrchr(WMApplication.argv[0], '/');
+		if (ptr_slash != NULL) {
+			char tmp[ptr_slash - WMApplication.argv[0] + 1];
+
+			strncpy(tmp, WMApplication.argv[0], sizeof(tmp)-1);
+			tmp[sizeof(tmp) - 1] = '\0';
+
+			path = checkFile(tmp, NULL, ext, resource);
+			if (path)
+				goto out;
+		}
+	}
+
+	snprintf(buffer, sizeof(buffer), "Applications/%s.app", WMApplication.applicationName);
+	path = checkFile(GETENV("WMAKER_USER_ROOT"), buffer, ext, resource);
+	if (path)
+		goto out;
+
+	slen = strlen(WMApplication.applicationName) + sizeof("/.app");
+	appdir = wmalloc(slen);
+	if (snprintf(appdir, slen, "/%s.app", WMApplication.applicationName) >= slen)
+		goto out;
+
+	gsuserapps = GETENV("GNUSTEP_USER_APPS");
+	if (!gsuserapps) {
+		snprintf(buffer, sizeof(buffer), "%s/Applications", wusergnusteppath());
+		gsuserapps = buffer;
+	}
+	path = checkFile(gsuserapps, appdir, ext, resource);
+	if (path)
+		goto out;
+
+	gslocapps = GETENV("GNUSTEP_LOCAL_APPS");
+	if (!gslocapps)
+		gslocapps = "/usr/local/lib/GNUstep/Applications";
+	path = checkFile(gslocapps, appdir, ext, resource);
+	if (path)
+		goto out;
+
+	gssysapps = GETENV("GNUSTEP_SYSTEM_APPS");
+	if (!gssysapps)
+		gssysapps = "/usr/lib/GNUstep/Applications";
+	path = checkFile(gssysapps, appdir, ext, resource);
+	if (path)
+		goto out;
+
+	path = checkFile("/usr/GNUstep/System/Applications", appdir, ext, resource); /* falls through */
+
+out:
+	if (appdir)
+		wfree(appdir);
+
+	return path;
+
+}

bazel/WINGs/wappresource.c

@@ -0,0 +1,148 @@
+
+#include <unistd.h>
+
+#include "WINGs/WINGsP.h"
+
+#include <X11/Xutil.h>
+
+#include "wmaker/GNUstep.h"
+
+
+void WMSetApplicationIconWindow(WMScreen * scr, Window window)
+{
+	scr->applicationIconWindow = window;
+
+	if (scr->groupLeader) {
+		XWMHints *hints;
+
+		hints = XGetWMHints(scr->display, scr->groupLeader);
+		hints->flags |= IconWindowHint;
+		hints->icon_window = window;
+
+		XSetWMHints(scr->display, scr->groupLeader, hints);
+		XFree(hints);
+	}
+}
+
+void WMSetApplicationIconImage(WMScreen * scr, RImage * image)
+{
+	WMPixmap *icon;
+
+	if (scr->applicationIconImage == image)
+		return;
+
+	if (scr->applicationIconImage)
+		RReleaseImage(scr->applicationIconImage);
+
+	scr->applicationIconImage = RRetainImage(image);
+
+	/* TODO: check whether we should set the pixmap only if there's none yet */
+	if (image != NULL && (icon = WMCreatePixmapFromRImage(scr, image, 128)) != NULL) {
+		WMSetApplicationIconPixmap(scr, icon);
+		WMReleasePixmap(icon);
+	}
+}
+
+RImage *WMGetApplicationIconImage(WMScreen * scr)
+{
+	return scr->applicationIconImage;
+}
+
+void WMSetApplicationIconPixmap(WMScreen * scr, WMPixmap * icon)
+{
+	if (scr->applicationIconPixmap == icon)
+		return;
+
+	if (scr->applicationIconPixmap)
+		WMReleasePixmap(scr->applicationIconPixmap);
+
+	scr->applicationIconPixmap = WMRetainPixmap(icon);
+
+	if (scr->groupLeader) {
+		XWMHints *hints;
+
+		hints = XGetWMHints(scr->display, scr->groupLeader);
+		hints->flags |= IconPixmapHint | IconMaskHint;
+		hints->icon_pixmap = (icon != NULL ? icon->pixmap : None);
+		hints->icon_mask = (icon != NULL ? icon->mask : None);
+
+		XSetWMHints(scr->display, scr->groupLeader, hints);
+		XFree(hints);
+	}
+}
+
+WMPixmap *WMGetApplicationIconPixmap(WMScreen * scr)
+{
+	return scr->applicationIconPixmap;
+}
+
+WMPixmap *WMCreateApplicationIconBlendedPixmap(WMScreen * scr, const RColor * color)
+{
+	WMPixmap *pix;
+
+	if (scr->applicationIconImage) {
+		static const RColor gray = {
+			/* red   */ 0xAE,
+			/* green */ 0xAA,
+			/* blue  */ 0xAE,
+			/* alpha */ 0xFF
+		};
+
+		if (!color)
+			color = &gray;
+
+		pix = WMCreateBlendedPixmapFromRImage(scr, scr->applicationIconImage, color);
+	} else {
+		pix = NULL;
+	}
+
+	return pix;
+}
+
+void WMSetApplicationHasAppIcon(WMScreen * scr, Bool flag)
+{
+	scr->aflags.hasAppIcon = ((flag == 0) ? 0 : 1);
+}
+
+void W_InitApplication(WMScreen * scr)
+{
+	Window leader;
+	XClassHint *classHint;
+	XWMHints *hints;
+
+	leader = XCreateSimpleWindow(scr->display, scr->rootWin, -1, -1, 1, 1, 0, 0, 0);
+
+	if (!scr->aflags.simpleApplication) {
+		classHint = XAllocClassHint();
+		classHint->res_name = "groupLeader";
+		classHint->res_class = WMApplication.applicationName;
+		XSetClassHint(scr->display, leader, classHint);
+		XFree(classHint);
+
+		XSetCommand(scr->display, leader, WMApplication.argv, WMApplication.argc);
+
+		hints = XAllocWMHints();
+
+		hints->flags = WindowGroupHint;
+		hints->window_group = leader;
+
+		/* This code will never actually be reached, because to have
+		 * scr->applicationIconPixmap set we need to have a screen first,
+		 * but this function is called in the screen creation process.
+		 * -Dan
+		 */
+		if (scr->applicationIconPixmap) {
+			hints->flags |= IconPixmapHint;
+			hints->icon_pixmap = scr->applicationIconPixmap->pixmap;
+			if (scr->applicationIconPixmap->mask) {
+				hints->flags |= IconMaskHint;
+				hints->icon_mask = scr->applicationIconPixmap->mask;
+			}
+		}
+
+		XSetWMHints(scr->display, leader, hints);
+
+		XFree(hints);
+	}
+	scr->groupLeader = leader;
+}

bazel/WINGs/wballoon.c

@@ -0,0 +1,476 @@
+
+#include "WINGs/wconfig.h"
+#include "WINGs/WINGsP.h"
+
+#ifdef USE_XSHAPE
+#include <X11/extensions/shape.h>
+#endif
+
+typedef struct W_Balloon {
+	W_View *view;
+
+	WMHashTable *table;	/* Table from view ptr to text */
+
+	WMColor *backColor;
+	WMColor *textColor;
+	WMFont *font;
+
+	WMHandlerID timer;	/* timer for showing balloon */
+
+	WMHandlerID noDelayTimer;
+
+	int delay;
+
+	Window forWindow;	/* window for which the balloon
+				 * is being show in the moment */
+
+	struct {
+		WMAlignment alignment:2;
+		unsigned enabled:1;
+
+		unsigned noDelay:1;
+	} flags;
+} Balloon;
+
+#define DEFAULT_WIDTH		60
+#define DEFAULT_HEIGHT		14
+#define DEFAULT_ALIGNMENT	WALeft
+#define DEFAULT_DELAY		500
+
+#define NO_DELAY_DELAY		150
+
+static void destroyBalloon(Balloon * bPtr);
+
+static void handleEvents(XEvent * event, void *data);
+
+static void showText(Balloon * bPtr, int x, int y, int w, int h, const char *text);
+
+struct W_Balloon *W_CreateBalloon(WMScreen * scr)
+{
+	Balloon *bPtr;
+
+	bPtr = wmalloc(sizeof(Balloon));
+
+	bPtr->view = W_CreateUnmanagedTopView(scr);
+	if (!bPtr->view) {
+		wfree(bPtr);
+		return NULL;
+	}
+	bPtr->view->self = bPtr;
+
+	bPtr->textColor = WMRetainColor(bPtr->view->screen->black);
+
+	WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);
+
+	W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+	bPtr->flags.alignment = DEFAULT_ALIGNMENT;
+
+	bPtr->table = WMCreateHashTable(WMIntHashCallbacks);
+
+	bPtr->delay = DEFAULT_DELAY;
+
+	bPtr->flags.enabled = 1;
+
+	return bPtr;
+}
+
+void WMSetBalloonTextAlignment(WMScreen * scr, WMAlignment alignment)
+{
+	scr->balloon->flags.alignment = alignment;
+
+}
+
+void WMSetBalloonTextForView(const char *text, WMView * view)
+{
+	char *oldText = NULL;
+	WMScreen *scr = view->screen;
+
+	if (text) {
+		oldText = WMHashInsert(scr->balloon->table, view, wstrdup(text));
+	} else {
+		oldText = WMHashGet(scr->balloon->table, view);
+
+		WMHashRemove(scr->balloon->table, view);
+	}
+
+	if (oldText) {
+		wfree(oldText);
+	}
+}
+
+void WMSetBalloonFont(WMScreen * scr, WMFont * font)
+{
+	Balloon *bPtr = scr->balloon;
+
+	if (bPtr->font != NULL)
+		WMReleaseFont(bPtr->font);
+
+	if (font)
+		bPtr->font = WMRetainFont(font);
+	else
+		bPtr->font = NULL;
+}
+
+void WMSetBalloonTextColor(WMScreen * scr, WMColor * color)
+{
+	Balloon *bPtr = scr->balloon;
+
+	if (bPtr->textColor)
+		WMReleaseColor(bPtr->textColor);
+
+	bPtr->textColor = WMRetainColor(color);
+}
+
+void WMSetBalloonDelay(WMScreen * scr, int delay)
+{
+	scr->balloon->delay = delay;
+}
+
+void WMSetBalloonEnabled(WMScreen * scr, Bool flag)
+{
+	scr->balloon->flags.enabled = ((flag == 0) ? 0 : 1);
+
+	W_UnmapView(scr->balloon->view);
+}
+
+static void clearNoDelay(void *data)
+{
+	Balloon *bPtr = (Balloon *) data;
+
+	bPtr->flags.noDelay = 0;
+	bPtr->noDelayTimer = NULL;
+}
+
+void W_BalloonHandleLeaveView(WMView * view)
+{
+	Balloon *bPtr = view->screen->balloon;
+
+	if (bPtr->forWindow == view->window) {
+		if (bPtr->view->flags.mapped) {
+			W_UnmapView(bPtr->view);
+			bPtr->noDelayTimer = WMAddTimerHandler(NO_DELAY_DELAY, clearNoDelay, bPtr);
+		}
+		if (bPtr->timer)
+			WMDeleteTimerHandler(bPtr->timer);
+
+		bPtr->timer = NULL;
+
+		bPtr->forWindow = None;
+	}
+}
+
+/*
+ * botar balao perto do cursor
+ * so mapear balao se o mouse ficar parado pelo delay
+ *
+ */
+
+static void showBalloon(void *data)
+{
+	char *text;
+	WMView *view = (WMView *) data;
+	Balloon *bPtr = view->screen->balloon;
+	int x, y;
+	Window foo;
+
+	bPtr->timer = NULL;
+
+	text = WMHashGet(bPtr->table, view);
+	if (!text)
+		return;
+
+	XTranslateCoordinates(view->screen->display, view->window, view->screen->rootWin, 0, 0, &x, &y, &foo);
+
+	if (!bPtr->view->flags.realized)
+		W_RealizeView(bPtr->view);
+
+	showText(bPtr, x, y, view->size.width, view->size.height, text);
+
+	bPtr->flags.noDelay = 1;
+}
+
+void W_BalloonHandleEnterView(WMView * view)
+{
+	Balloon *bPtr = view->screen->balloon;
+	char *text;
+
+	if (!bPtr->flags.enabled)
+		return;
+
+	text = WMHashGet(bPtr->table, view);
+	if (!text) {
+		if (bPtr->view->flags.realized)
+			W_UnmapView(bPtr->view);
+
+		return;
+	}
+
+	if (bPtr->timer)
+		WMDeleteTimerHandler(bPtr->timer);
+	bPtr->timer = NULL;
+
+	if (bPtr->noDelayTimer)
+		WMDeleteTimerHandler(bPtr->noDelayTimer);
+	bPtr->noDelayTimer = NULL;
+
+	bPtr->forWindow = view->window;
+
+	if (bPtr->flags.noDelay) {
+		bPtr->timer = NULL;
+
+		showBalloon(view);
+	} else {
+		bPtr->timer = WMAddTimerHandler(bPtr->delay, showBalloon, view);
+	}
+}
+
+#define TOP	0
+#define BOTTOM	1
+#define LEFT	0
+#define RIGHT	2
+
+#define 	SPACE	12
+
+static void drawBalloon(WMScreen * scr, Pixmap bitmap, Pixmap pix, int x, int y, int w, int h, int side)
+{
+	Display *dpy = scr->display;
+	WMColor *white = WMWhiteColor(scr);
+	WMColor *black = WMBlackColor(scr);
+	GC bgc = scr->monoGC;
+	GC gc = WMColorGC(white);
+	int rad = h * 3 / 10;
+	XPoint pt[3], ipt[3];
+	int w1;
+
+	/* outline */
+	XSetForeground(dpy, bgc, 1);
+
+	XFillArc(dpy, bitmap, bgc, x, y, rad, rad, 90 * 64, 90 * 64);
+	XFillArc(dpy, bitmap, bgc, x, y + h - 1 - rad, rad, rad, 180 * 64, 90 * 64);
+
+	XFillArc(dpy, bitmap, bgc, x + w - 1 - rad, y, rad, rad, 0 * 64, 90 * 64);
+	XFillArc(dpy, bitmap, bgc, x + w - 1 - rad, y + h - 1 - rad, rad, rad, 270 * 64, 90 * 64);
+
+	XFillRectangle(dpy, bitmap, bgc, x, y + rad / 2, w, h - rad);
+	XFillRectangle(dpy, bitmap, bgc, x + rad / 2, y, w - rad, h);
+
+	/* interior */
+	XFillArc(dpy, pix, gc, x + 1, y + 1, rad, rad, 90 * 64, 90 * 64);
+	XFillArc(dpy, pix, gc, x + 1, y + h - 2 - rad, rad, rad, 180 * 64, 90 * 64);
+
+	XFillArc(dpy, pix, gc, x + w - 2 - rad, y + 1, rad, rad, 0 * 64, 90 * 64);
+	XFillArc(dpy, pix, gc, x + w - 2 - rad, y + h - 2 - rad, rad, rad, 270 * 64, 90 * 64);
+
+	XFillRectangle(dpy, pix, gc, x + 1, y + 1 + rad / 2, w - 2, h - 2 - rad);
+	XFillRectangle(dpy, pix, gc, x + 1 + rad / 2, y + 1, w - 2 - rad, h - 2);
+
+	if (side & BOTTOM) {
+		pt[0].y = y + h - 1;
+		pt[1].y = y + h - 1 + SPACE;
+		pt[2].y = y + h - 1;
+		ipt[0].y = pt[0].y - 1;
+		ipt[1].y = pt[1].y - 1;
+		ipt[2].y = pt[2].y - 1;
+	} else {
+		pt[0].y = y;
+		pt[1].y = y - SPACE;
+		pt[2].y = y;
+		ipt[0].y = pt[0].y + 1;
+		ipt[1].y = pt[1].y + 1;
+		ipt[2].y = pt[2].y + 1;
+	}
+
+	/*w1 = WMAX(h, 24); */
+	w1 = WMAX(h, 21);
+
+	if (side & RIGHT) {
+		pt[0].x = x + w - w1 + 2 * w1 / 16;
+		pt[1].x = x + w - w1 + 11 * w1 / 16;
+		pt[2].x = x + w - w1 + 7 * w1 / 16;
+		ipt[0].x = x + 1 + w - w1 + 2 * (w1 - 1) / 16;
+		ipt[1].x = x + 1 + w - w1 + 11 * (w1 - 1) / 16;
+		ipt[2].x = x + 1 + w - w1 + 7 * (w1 - 1) / 16;
+		/*ipt[0].x = pt[0].x+1;
+		   ipt[1].x = pt[1].x;
+		   ipt[2].x = pt[2].x; */
+	} else {
+		pt[0].x = x + w1 - 2 * w1 / 16;
+		pt[1].x = x + w1 - 11 * w1 / 16;
+		pt[2].x = x + w1 - 7 * w1 / 16;
+		ipt[0].x = x - 1 + w1 - 2 * (w1 - 1) / 16;
+		ipt[1].x = x - 1 + w1 - 11 * (w1 - 1) / 16;
+		ipt[2].x = x - 1 + w1 - 7 * (w1 - 1) / 16;
+		/*ipt[0].x = pt[0].x-1;
+		   ipt[1].x = pt[1].x;
+		   ipt[2].x = pt[2].x; */
+	}
+
+	XFillPolygon(dpy, bitmap, bgc, pt, 3, Convex, CoordModeOrigin);
+	XFillPolygon(dpy, pix, gc, ipt, 3, Convex, CoordModeOrigin);
+
+	/* fix outline */
+	XDrawLines(dpy, pix, WMColorGC(black), pt, 3, CoordModeOrigin);
+	if (side & RIGHT) {
+		pt[0].x++;
+		pt[2].x--;
+	} else {
+		pt[0].x--;
+		pt[2].x++;
+	}
+	XDrawLines(dpy, pix, WMColorGC(black), pt, 3, CoordModeOrigin);
+
+	WMReleaseColor(white);
+	WMReleaseColor(black);
+}
+
+static Pixmap makePixmap(WMScreen * scr, int width, int height, int side, Pixmap * mask)
+{
+	Display *dpy = WMScreenDisplay(scr);
+	Pixmap bitmap;
+	Pixmap pixmap;
+	int x, y;
+	WMColor *black = WMBlackColor(scr);
+
+	bitmap = XCreatePixmap(dpy, scr->rootWin, width + SPACE, height + SPACE, 1);
+
+	XSetForeground(dpy, scr->monoGC, 0);
+	XFillRectangle(dpy, bitmap, scr->monoGC, 0, 0, width + SPACE, height + SPACE);
+
+	pixmap = XCreatePixmap(dpy, scr->rootWin, width + SPACE, height + SPACE, scr->depth);
+
+	XFillRectangle(dpy, pixmap, WMColorGC(black), 0, 0, width + SPACE, height + SPACE);
+
+	if (side & BOTTOM) {
+		y = 0;
+	} else {
+		y = SPACE;
+	}
+	x = 0;
+
+	drawBalloon(scr, bitmap, pixmap, x, y, width, height, side);
+
+	*mask = bitmap;
+
+	WMReleaseColor(black);
+
+	return pixmap;
+}
+
+static void showText(Balloon * bPtr, int x, int y, int w, int h, const char *text)
+{
+	WMScreen *scr = bPtr->view->screen;
+	Display *dpy = WMScreenDisplay(scr);
+	int width;
+	int height;
+	Pixmap pixmap;
+	Pixmap mask;
+	WMFont *font = bPtr->font ? bPtr->font : scr->normalFont;
+	int textHeight;
+	int side = 0;
+	int ty;
+	int bx, by;
+
+	{
+		int w;
+		const char *ptr, *ptr2;
+
+		ptr2 = ptr = text;
+		width = 0;
+		while (ptr && ptr2) {
+			ptr2 = strchr(ptr, '\n');
+			if (ptr2) {
+				w = WMWidthOfString(font, ptr, ptr2 - ptr);
+			} else {
+				w = WMWidthOfString(font, ptr, strlen(ptr));
+			}
+			if (w > width)
+				width = w;
+			ptr = ptr2 + 1;
+		}
+	}
+
+	width += 16;
+
+	textHeight = W_GetTextHeight(font, text, width, False);
+
+	height = textHeight + 4;
+
+	if (height < 16)
+		height = 16;
+	if (width < height)
+		width = height;
+
+	if (x + width > scr->rootView->size.width) {
+		side = RIGHT;
+		bx = x - width + w / 2;
+		if (bx < 0)
+			bx = 0;
+	} else {
+		side = LEFT;
+		bx = x + w / 2;
+	}
+	if (bx + width > scr->rootView->size.width)
+		bx = scr->rootView->size.width - width;
+
+	if (y - (height + SPACE) < 0) {
+		side |= TOP;
+		by = y + h - 1;
+		ty = SPACE;
+	} else {
+		side |= BOTTOM;
+		by = y - (height + SPACE);
+		ty = 0;
+	}
+	pixmap = makePixmap(scr, width, height, side, &mask);
+
+	W_PaintText(bPtr->view, pixmap, font, 8, ty + (height - textHeight) / 2,
+		    width, bPtr->flags.alignment,
+		    bPtr->textColor ? bPtr->textColor : scr->black, False, text, strlen(text));
+
+	XSetWindowBackgroundPixmap(dpy, bPtr->view->window, pixmap);
+
+	W_ResizeView(bPtr->view, width, height + SPACE);
+
+	XFreePixmap(dpy, pixmap);
+
+#ifdef USE_XSHAPE
+	XShapeCombineMask(dpy, bPtr->view->window, ShapeBounding, 0, 0, mask, ShapeSet);
+#endif
+	XFreePixmap(dpy, mask);
+
+	W_MoveView(bPtr->view, bx, by);
+
+	W_MapView(bPtr->view);
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	Balloon *bPtr = (Balloon *) data;
+
+	switch (event->type) {
+	case DestroyNotify:
+		destroyBalloon(bPtr);
+		break;
+	}
+}
+
+static void destroyBalloon(Balloon * bPtr)
+{
+	WMHashEnumerator e;
+	char *str;
+
+	e = WMEnumerateHashTable(bPtr->table);
+
+	while ((str = WMNextHashEnumeratorItem(&e))) {
+		wfree(str);
+	}
+	WMFreeHashTable(bPtr->table);
+
+	if (bPtr->textColor)
+		WMReleaseColor(bPtr->textColor);
+
+	if (bPtr->font)
+		WMReleaseFont(bPtr->font);
+
+	wfree(bPtr);
+}

bazel/WINGs/wbox.c

@@ -0,0 +1,247 @@
+
+#include "WINGs/WINGsP.h"
+
+typedef struct {
+	WMView *view;
+	int minSize;
+	int maxSize;
+	int space;
+	unsigned expand:1;
+	unsigned fill:1;
+	unsigned end:1;
+} SubviewItem;
+
+typedef struct W_Box {
+	W_Class widgetClass;
+	W_View *view;
+
+	WMArray *subviews;
+
+	short borderWidth;
+
+	unsigned horizontal:1;
+} Box;
+
+#define DEFAULT_WIDTH		40
+#define DEFAULT_HEIGHT		40
+
+static void destroyBox(Box * bPtr);
+
+static void handleEvents(XEvent * event, void *data);
+
+static void didResize(struct W_ViewDelegate *, WMView *);
+
+static W_ViewDelegate delegate = {
+	NULL,
+	NULL,
+	didResize,
+	NULL,
+	NULL
+};
+
+WMBox *WMCreateBox(WMWidget * parent)
+{
+	Box *bPtr;
+
+	bPtr = wmalloc(sizeof(Box));
+
+	bPtr->widgetClass = WC_Box;
+
+	bPtr->view = W_CreateView(W_VIEW(parent));
+	if (!bPtr->view) {
+		wfree(bPtr);
+		return NULL;
+	}
+	bPtr->view->self = bPtr;
+
+	bPtr->view->delegate = &delegate;
+
+	bPtr->subviews = WMCreateArrayWithDestructor(2, wfree);
+
+	WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);
+
+	WMResizeWidget(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+
+	return bPtr;
+}
+
+typedef struct {
+	WMBox *box;
+	int total;
+	int expands;
+	int x, y;
+	int xe, ye;
+	int w, h;
+} BoxData;
+
+static void computeExpansion(void *object, void *cdata)
+{
+	SubviewItem *item = (SubviewItem *) object;
+	BoxData *eData = (BoxData *) cdata;
+
+	eData->total -= item->minSize;
+	eData->total -= item->space;
+	if (item->expand) {
+		eData->expands++;
+	}
+}
+
+static void doRearrange(void *object, void *cdata)
+{
+	SubviewItem *item = (SubviewItem *) object;
+	BoxData *eData = (BoxData *) cdata;
+
+	if (eData->box->horizontal) {
+		eData->w = item->minSize;
+		if (item->expand)
+			eData->w += eData->total / eData->expands;
+	} else {
+		eData->h = item->minSize;
+		if (item->expand)
+			eData->h += eData->total / eData->expands;
+	}
+	if (!item->end) {
+		W_MoveView(item->view, eData->x, eData->y);
+	}
+	W_ResizeView(item->view, eData->w, eData->h);
+	if (eData->box->horizontal) {
+		if (item->end)
+			eData->xe -= eData->w + item->space;
+		else
+			eData->x += eData->w + item->space;
+	} else {
+		if (item->end)
+			eData->ye -= eData->h + item->space;
+		else
+			eData->y += eData->h + item->space;
+	}
+	if (item->end) {
+		W_MoveView(item->view, eData->xe, eData->ye);
+	}
+}
+
+static void rearrange(WMBox * box)
+{
+	BoxData eData;
+
+	eData.box = box;
+	eData.x = eData.y = box->borderWidth;
+	eData.w = eData.h = 1;
+	eData.expands = 0;
+
+	if (box->horizontal) {
+		eData.ye = box->borderWidth;
+		eData.xe = WMWidgetWidth(box) - box->borderWidth;
+		eData.h = WMWidgetHeight(box) - 2 * box->borderWidth;
+		eData.total = WMWidgetWidth(box) - 2 * box->borderWidth;
+	} else {
+		eData.xe = box->borderWidth;
+		eData.ye = WMWidgetHeight(box) - box->borderWidth;
+		eData.w = WMWidgetWidth(box) - 2 * box->borderWidth;
+		eData.total = WMWidgetHeight(box) - 2 * box->borderWidth;
+	}
+
+	if (eData.w <= 0 || eData.h <= 0 || eData.total <= 0) {
+		return;
+	}
+
+	WMMapArray(box->subviews, computeExpansion, &eData);
+	WMMapArray(box->subviews, doRearrange, &eData);
+}
+
+void WMSetBoxBorderWidth(WMBox * box, unsigned width)
+{
+	if (box->borderWidth != width) {
+		box->borderWidth = width;
+		rearrange(box);
+	}
+}
+
+void WMAddBoxSubview(WMBox * bPtr, WMView * view, Bool expand, Bool fill, int minSize, int maxSize, int space)
+{
+	SubviewItem *subView;
+
+	subView = wmalloc(sizeof(SubviewItem));
+	subView->view = view;
+	subView->minSize = minSize;
+	subView->maxSize = maxSize;
+	subView->expand = expand;
+	subView->fill = fill;
+	subView->space = space;
+	subView->end = 0;
+
+	WMAddToArray(bPtr->subviews, subView);
+
+	rearrange(bPtr);
+}
+
+void WMAddBoxSubviewAtEnd(WMBox * bPtr, WMView * view, Bool expand, Bool fill, int minSize, int maxSize, int space)
+{
+	SubviewItem *subView;
+
+	subView = wmalloc(sizeof(SubviewItem));
+	subView->view = view;
+	subView->minSize = minSize;
+	subView->maxSize = maxSize;
+	subView->expand = expand;
+	subView->fill = fill;
+	subView->space = space;
+	subView->end = 1;
+
+	WMAddToArray(bPtr->subviews, subView);
+
+	rearrange(bPtr);
+}
+
+static int matchView(const void *item, const void *cdata)
+{
+	return (((SubviewItem *) item)->view == (WMView *) cdata);
+}
+
+void WMRemoveBoxSubview(WMBox * bPtr, WMView * view)
+{
+	if (WMRemoveFromArrayMatching(bPtr->subviews, matchView, view)) {
+		rearrange(bPtr);
+	}
+}
+
+void WMSetBoxHorizontal(WMBox * box, Bool flag)
+{
+	/* make sure flag is either 0 or 1 no matter what true value was passed */
+	flag = ((flag == 0) ? 0 : 1);
+	if (box->horizontal != flag) {
+		box->horizontal = flag;
+		rearrange(box);
+	}
+}
+
+static void destroyBox(Box * bPtr)
+{
+	WMFreeArray(bPtr->subviews);
+	wfree(bPtr);
+}
+
+static void didResize(struct W_ViewDelegate *delegate, WMView * view)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) delegate;
+
+	rearrange(view->self);
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	Box *bPtr = (Box *) data;
+
+	CHECK_CLASS(data, WC_Box);
+
+	switch (event->type) {
+	case DestroyNotify:
+		destroyBox(bPtr);
+		break;
+
+	case ConfigureNotify:
+		rearrange(bPtr);
+		break;
+	}
+}

bazel/WINGs/wbutton.c

@@ -0,0 +1,777 @@
+
+#include "WINGs/WINGsP.h"
+
+typedef struct W_Button {
+	W_Class widgetClass;
+	WMView *view;
+
+	char *caption;
+
+	char *altCaption;
+
+	WMFont *font;
+
+	WMColor *textColor;
+	WMColor *altTextColor;
+	WMColor *disTextColor;
+
+	W_Pixmap *image;
+	W_Pixmap *altImage;
+	W_Pixmap *tsImage;
+
+	W_Pixmap *dimage;
+
+	void *clientData;
+	WMAction *action;
+
+	int tag;
+
+	int groupIndex;
+
+	float periodicDelay;
+	float periodicInterval;
+
+	WMHandlerID *timer;	/* for continuous mode */
+
+	struct {
+		WMButtonType type:4;
+		WMImagePosition imagePosition:4;
+		WMAlignment alignment:2;
+
+		unsigned int selected:2;
+
+		unsigned int enabled:1;
+
+		unsigned int dimsWhenDisabled:1;
+
+		unsigned int bordered:1;
+
+		unsigned int springLoaded:1;
+
+		unsigned int pushIn:1;	/* change relief while pushed */
+
+		unsigned int pushLight:1;	/* highlight while pushed */
+
+		unsigned int pushChange:1;	/* change caption while pushed */
+
+		unsigned int stateLight:1;	/* state indicated by highlight */
+
+		unsigned int stateChange:1;	/* state indicated by caption change */
+
+		unsigned int statePush:1;	/* state indicated by relief */
+
+		unsigned int continuous:1;	/* continually perform action */
+
+		unsigned int prevSelected:1;
+
+		unsigned int pushed:1;
+
+		unsigned int wasPushed:1;
+
+		unsigned int redrawPending:1;
+
+		unsigned int addedObserver:1;
+	} flags;
+} Button;
+
+#define DEFAULT_BUTTON_WIDTH	60
+#define DEFAULT_BUTTON_HEIGHT	24
+#define DEFAULT_BUTTON_ALIGNMENT	WACenter
+#define DEFAULT_BUTTON_IS_BORDERED	True
+
+#define DEFAULT_RADIO_WIDTH	100
+#define DEFAULT_RADIO_HEIGHT	20
+#define DEFAULT_RADIO_ALIGNMENT	WALeft
+#define DEFAULT_RADIO_IMAGE_POSITION	WIPLeft
+#define DEFAULT_RADIO_TEXT	"Radio"
+
+#define DEFAULT_SWITCH_WIDTH	100
+#define DEFAULT_SWITCH_HEIGHT	20
+#define DEFAULT_SWITCH_ALIGNMENT	WALeft
+#define DEFAULT_SWITCH_IMAGE_POSITION	WIPLeft
+#define DEFAULT_SWITCH_TEXT	"Switch"
+
+static void destroyButton(Button * bPtr);
+static void paintButton(Button * bPtr);
+
+static void handleEvents(XEvent * event, void *data);
+static void handleActionEvents(XEvent * event, void *data);
+
+static char *WMPushedRadioNotification = "WMPushedRadioNotification";
+
+
+WMButton *WMCreateCustomButton(WMWidget * parent, int behaviourMask)
+{
+	Button *bPtr;
+
+	bPtr = wmalloc(sizeof(Button));
+
+	bPtr->widgetClass = WC_Button;
+
+	bPtr->view = W_CreateView(W_VIEW(parent));
+	if (!bPtr->view) {
+		wfree(bPtr);
+		return NULL;
+	}
+	bPtr->view->self = bPtr;
+
+	bPtr->flags.type = 0;
+
+	bPtr->flags.springLoaded = (behaviourMask & WBBSpringLoadedMask) != 0;
+	bPtr->flags.pushIn = (behaviourMask & WBBPushInMask) != 0;
+	bPtr->flags.pushChange = (behaviourMask & WBBPushChangeMask) != 0;
+	bPtr->flags.pushLight = (behaviourMask & WBBPushLightMask) != 0;
+	bPtr->flags.stateLight = (behaviourMask & WBBStateLightMask) != 0;
+	bPtr->flags.stateChange = (behaviourMask & WBBStateChangeMask) != 0;
+	bPtr->flags.statePush = (behaviourMask & WBBStatePushMask) != 0;
+
+	W_ResizeView(bPtr->view, DEFAULT_BUTTON_WIDTH, DEFAULT_BUTTON_HEIGHT);
+	bPtr->flags.alignment = DEFAULT_BUTTON_ALIGNMENT;
+	bPtr->flags.bordered = DEFAULT_BUTTON_IS_BORDERED;
+
+	bPtr->flags.enabled = 1;
+	bPtr->flags.dimsWhenDisabled = 1;
+
+	WMCreateEventHandler(bPtr->view, ExposureMask | StructureNotifyMask, handleEvents, bPtr);
+
+	WMCreateEventHandler(bPtr->view, ButtonPressMask | ButtonReleaseMask
+			     | EnterWindowMask | LeaveWindowMask, handleActionEvents, bPtr);
+
+	W_ResizeView(bPtr->view, DEFAULT_BUTTON_WIDTH, DEFAULT_BUTTON_HEIGHT);
+	bPtr->flags.alignment = DEFAULT_BUTTON_ALIGNMENT;
+	bPtr->flags.bordered = DEFAULT_BUTTON_IS_BORDERED;
+
+	return bPtr;
+}
+
+WMButton *WMCreateButton(WMWidget * parent, WMButtonType type)
+{
+	W_Screen *scrPtr = W_VIEW(parent)->screen;
+	Button *bPtr;
+
+	switch (type) {
+	case WBTMomentaryPush:
+		bPtr = WMCreateCustomButton(parent, WBBSpringLoadedMask | WBBPushInMask | WBBPushLightMask);
+		break;
+
+	case WBTMomentaryChange:
+		bPtr = WMCreateCustomButton(parent, WBBSpringLoadedMask | WBBPushChangeMask);
+		break;
+
+	case WBTPushOnPushOff:
+		bPtr = WMCreateCustomButton(parent, WBBPushInMask | WBBStatePushMask | WBBStateLightMask);
+		break;
+
+	case WBTToggle:
+		bPtr = WMCreateCustomButton(parent, WBBPushInMask | WBBStateChangeMask | WBBStatePushMask);
+		break;
+
+	case WBTOnOff:
+		bPtr = WMCreateCustomButton(parent, WBBStateLightMask);
+		break;
+
+	case WBTSwitch:
+		bPtr = WMCreateCustomButton(parent, WBBStateChangeMask);
+		bPtr->flags.bordered = 0;
+		bPtr->image = WMRetainPixmap(scrPtr->checkButtonImageOff);
+		bPtr->altImage = WMRetainPixmap(scrPtr->checkButtonImageOn);
+		break;
+
+	case WBTRadio:
+		bPtr = WMCreateCustomButton(parent, WBBStateChangeMask);
+		bPtr->flags.bordered = 0;
+		bPtr->image = WMRetainPixmap(scrPtr->radioButtonImageOff);
+		bPtr->altImage = WMRetainPixmap(scrPtr->radioButtonImageOn);
+		break;
+
+	case WBTTriState:
+		bPtr = WMCreateCustomButton(parent, WBBStateChangeMask);
+		bPtr->flags.bordered = 0;
+		bPtr->image = WMRetainPixmap(scrPtr->tristateButtonImageOff);
+		bPtr->altImage = WMRetainPixmap(scrPtr->tristateButtonImageOn);
+		bPtr->tsImage = WMRetainPixmap(scrPtr->tristateButtonImageTri);
+		break;
+
+	default:
+	case WBTMomentaryLight:
+		bPtr = WMCreateCustomButton(parent, WBBSpringLoadedMask | WBBPushLightMask);
+		bPtr->flags.bordered = 1;
+		break;
+	}
+
+	bPtr->flags.type = type;
+
+	if (type == WBTRadio) {
+		W_ResizeView(bPtr->view, DEFAULT_RADIO_WIDTH, DEFAULT_RADIO_HEIGHT);
+		WMSetButtonText(bPtr, DEFAULT_RADIO_TEXT);
+		bPtr->flags.alignment = DEFAULT_RADIO_ALIGNMENT;
+		bPtr->flags.imagePosition = DEFAULT_RADIO_IMAGE_POSITION;
+	} else if (type == WBTSwitch || type == WBTTriState) {
+		W_ResizeView(bPtr->view, DEFAULT_SWITCH_WIDTH, DEFAULT_SWITCH_HEIGHT);
+		WMSetButtonText(bPtr, DEFAULT_SWITCH_TEXT);
+		bPtr->flags.alignment = DEFAULT_SWITCH_ALIGNMENT;
+		bPtr->flags.imagePosition = DEFAULT_SWITCH_IMAGE_POSITION;
+	}
+
+	return bPtr;
+}
+
+static void updateDisabledMask(WMButton * bPtr)
+{
+	WMScreen *scr = WMWidgetScreen(bPtr);
+	Display *dpy = scr->display;
+
+	if (bPtr->image) {
+		XGCValues gcv;
+
+		if (bPtr->dimage->mask) {
+			XFreePixmap(dpy, bPtr->dimage->mask);
+			bPtr->dimage->mask = None;
+		}
+
+		if (bPtr->flags.dimsWhenDisabled) {
+			bPtr->dimage->mask = XCreatePixmap(dpy, scr->stipple,
+							   bPtr->dimage->width, bPtr->dimage->height, 1);
+
+			XSetForeground(dpy, scr->monoGC, 0);
+			XFillRectangle(dpy, bPtr->dimage->mask, scr->monoGC, 0, 0,
+				       bPtr->dimage->width, bPtr->dimage->height);
+
+			gcv.foreground = 1;
+			gcv.background = 0;
+			gcv.stipple = scr->stipple;
+			gcv.fill_style = FillStippled;
+			gcv.clip_mask = bPtr->image->mask;
+			gcv.clip_x_origin = 0;
+			gcv.clip_y_origin = 0;
+
+			XChangeGC(dpy, scr->monoGC, GCForeground | GCBackground | GCStipple
+				  | GCFillStyle | GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
+
+			XFillRectangle(dpy, bPtr->dimage->mask, scr->monoGC, 0, 0,
+				       bPtr->dimage->width, bPtr->dimage->height);
+
+			gcv.fill_style = FillSolid;
+			gcv.clip_mask = None;
+			XChangeGC(dpy, scr->monoGC, GCFillStyle | GCClipMask, &gcv);
+		}
+	}
+}
+
+void WMSetButtonImageDefault(WMButton * bPtr)
+{
+	WMSetButtonImage(bPtr, WMWidgetScreen(bPtr)->buttonArrow);
+	WMSetButtonAltImage(bPtr, WMWidgetScreen(bPtr)->pushedButtonArrow);
+}
+
+void WMSetButtonImage(WMButton * bPtr, WMPixmap * image)
+{
+	if (bPtr->image != NULL)
+		WMReleasePixmap(bPtr->image);
+	bPtr->image = WMRetainPixmap(image);
+
+	if (bPtr->dimage) {
+		bPtr->dimage->pixmap = None;
+		WMReleasePixmap(bPtr->dimage);
+		bPtr->dimage = NULL;
+	}
+
+	if (image) {
+		bPtr->dimage = WMCreatePixmapFromXPixmaps(WMWidgetScreen(bPtr),
+							  image->pixmap, None,
+							  image->width, image->height, image->depth);
+		updateDisabledMask(bPtr);
+	}
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+}
+
+void WMSetButtonAltImage(WMButton * bPtr, WMPixmap * image)
+{
+	if (bPtr->altImage != NULL)
+		WMReleasePixmap(bPtr->altImage);
+	bPtr->altImage = WMRetainPixmap(image);
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+}
+
+void WMSetButtonImagePosition(WMButton * bPtr, WMImagePosition position)
+{
+	bPtr->flags.imagePosition = position;
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+}
+
+void WMSetButtonTextAlignment(WMButton * bPtr, WMAlignment alignment)
+{
+	bPtr->flags.alignment = alignment;
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+}
+
+void WMSetButtonText(WMButton * bPtr, const char *text)
+{
+	if (bPtr->caption)
+		wfree(bPtr->caption);
+
+	if (text != NULL) {
+		bPtr->caption = wstrdup(text);
+	} else {
+		bPtr->caption = NULL;
+	}
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+}
+
+const char *WMGetButtonText(WMButton *bPtr)
+{
+	return bPtr->caption;
+}
+
+void WMSetButtonAltText(WMButton * bPtr, const char *text)
+{
+	if (bPtr->altCaption)
+		wfree(bPtr->altCaption);
+
+	if (text != NULL) {
+		bPtr->altCaption = wstrdup(text);
+	} else {
+		bPtr->altCaption = NULL;
+	}
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+}
+
+void WMSetButtonTextColor(WMButton * bPtr, WMColor * color)
+{
+	if (bPtr->textColor)
+		WMReleaseColor(bPtr->textColor);
+
+	bPtr->textColor = WMRetainColor(color);
+}
+
+void WMSetButtonAltTextColor(WMButton * bPtr, WMColor * color)
+{
+	if (bPtr->altTextColor)
+		WMReleaseColor(bPtr->altTextColor);
+
+	bPtr->altTextColor = WMRetainColor(color);
+}
+
+void WMSetButtonDisabledTextColor(WMButton * bPtr, WMColor * color)
+{
+	if (bPtr->disTextColor)
+		WMReleaseColor(bPtr->disTextColor);
+
+	bPtr->disTextColor = WMRetainColor(color);
+}
+
+void WMSetButtonSelected(WMButton * bPtr, int isSelected)
+{
+	if ((bPtr->flags.type == WBTTriState) && (isSelected < 0))
+		bPtr->flags.selected = 2;
+	else
+		bPtr->flags.selected = isSelected ? 1 : 0;
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+	if (bPtr->groupIndex > 0)
+		WMPostNotificationName(WMPushedRadioNotification, bPtr, NULL);
+}
+
+int WMGetButtonSelected(WMButton * bPtr)
+{
+	CHECK_CLASS(bPtr, WC_Button);
+
+	if ((bPtr->flags.type == WBTTriState) && (bPtr->flags.selected == 2))
+		return -1;
+
+	return bPtr->flags.selected;
+}
+
+void WMSetButtonBordered(WMButton * bPtr, int isBordered)
+{
+	bPtr->flags.bordered = isBordered;
+
+	if (bPtr->view->flags.realized) {
+		paintButton(bPtr);
+	}
+}
+
+void WMSetButtonFont(WMButton * bPtr, WMFont * font)
+{
+	if (bPtr->font)
+		WMReleaseFont(bPtr->font);
+
+	bPtr->font = WMRetainFont(font);
+}
+
+void WMSetButtonEnabled(WMButton * bPtr, Bool flag)
+{
+	bPtr->flags.enabled = ((flag == 0) ? 0 : 1);
+
+	if (bPtr->view->flags.mapped) {
+		paintButton(bPtr);
+	}
+}
+
+int WMGetButtonEnabled(WMButton * bPtr)
+{
+	CHECK_CLASS(bPtr, WC_Button);
+
+	return bPtr->flags.enabled;
+}
+
+void WMSetButtonImageDimsWhenDisabled(WMButton * bPtr, Bool flag)
+{
+	bPtr->flags.dimsWhenDisabled = ((flag == 0) ? 0 : 1);
+
+	updateDisabledMask(bPtr);
+}
+
+void WMSetButtonTag(WMButton * bPtr, int tag)
+{
+	bPtr->tag = tag;
+}
+
+void WMPerformButtonClick(WMButton * bPtr)
+{
+	CHECK_CLASS(bPtr, WC_Button);
+
+	if (!bPtr->flags.enabled)
+		return;
+
+	bPtr->flags.pushed = 1;
+	bPtr->flags.selected = 1;
+
+	if (bPtr->view->flags.mapped) {
+		paintButton(bPtr);
+		XFlush(WMScreenDisplay(WMWidgetScreen(bPtr)));
+		wusleep(20000);
+	}
+
+	bPtr->flags.pushed = 0;
+
+	if (bPtr->groupIndex > 0) {
+		WMPostNotificationName(WMPushedRadioNotification, bPtr, NULL);
+	}
+
+	if (bPtr->action)
+		(*bPtr->action) (bPtr, bPtr->clientData);
+
+	if (bPtr->view->flags.mapped)
+		paintButton(bPtr);
+}
+
+void WMSetButtonAction(WMButton * bPtr, WMAction * action, void *clientData)
+{
+	CHECK_CLASS(bPtr, WC_Button);
+
+	bPtr->action = action;
+
+	bPtr->clientData = clientData;
+}
+
+static void radioPushObserver(void *observerData, WMNotification * notification)
+{
+	WMButton *bPtr = (WMButton *) observerData;
+	WMButton *pushedButton = (WMButton *) WMGetNotificationObject(notification);
+
+	if (bPtr != pushedButton && pushedButton->groupIndex == bPtr->groupIndex && bPtr->groupIndex != 0) {
+		if (bPtr->flags.selected) {
+			bPtr->flags.selected = 0;
+			paintButton(bPtr);
+		}
+	}
+}
+
+void WMGroupButtons(WMButton * bPtr, WMButton * newMember)
+{
+	static int tagIndex = 0;
+
+	CHECK_CLASS(bPtr, WC_Button);
+	CHECK_CLASS(newMember, WC_Button);
+
+	if (!bPtr->flags.addedObserver) {
+		WMAddNotificationObserver(radioPushObserver, bPtr, WMPushedRadioNotification, NULL);
+		bPtr->flags.addedObserver = 1;
+	}
+	if (!newMember->flags.addedObserver) {
+		WMAddNotificationObserver(radioPushObserver, newMember, WMPushedRadioNotification, NULL);
+		newMember->flags.addedObserver = 1;
+	}
+
+	if (bPtr->groupIndex == 0) {
+		bPtr->groupIndex = ++tagIndex;
+	}
+	newMember->groupIndex = bPtr->groupIndex;
+}
+
+void WMSetButtonContinuous(WMButton * bPtr, Bool flag)
+{
+	bPtr->flags.continuous = ((flag == 0) ? 0 : 1);
+	if (bPtr->timer) {
+		WMDeleteTimerHandler(bPtr->timer);
+		bPtr->timer = NULL;
+	}
+}
+
+void WMSetButtonPeriodicDelay(WMButton * bPtr, float delay, float interval)
+{
+	bPtr->periodicInterval = interval;
+	bPtr->periodicDelay = delay;
+}
+
+static void paintButton(Button * bPtr)
+{
+	W_Screen *scrPtr = bPtr->view->screen;
+	WMReliefType relief;
+	int offset;
+	char *caption;
+	WMPixmap *image;
+	WMColor *textColor;
+	WMColor *backColor;
+
+	backColor = NULL;
+	caption = bPtr->caption;
+
+	if (bPtr->flags.enabled) {
+		textColor = (bPtr->textColor != NULL ? bPtr->textColor : scrPtr->black);
+	} else {
+		textColor = (bPtr->disTextColor != NULL ? bPtr->disTextColor : scrPtr->darkGray);
+	}
+
+	if (bPtr->flags.enabled || !bPtr->dimage)
+		image = bPtr->image;
+	else
+		image = bPtr->dimage;
+	offset = 0;
+	if (bPtr->flags.bordered)
+		relief = WRRaised;
+	else
+		relief = WRFlat;
+
+	if (bPtr->flags.selected) {
+		if (bPtr->flags.stateLight) {
+			backColor = scrPtr->white;
+			textColor = scrPtr->black;
+		}
+
+		if (bPtr->flags.stateChange) {
+			if (bPtr->altCaption)
+				caption = bPtr->altCaption;
+			if (bPtr->flags.selected == 2)
+				image = bPtr->tsImage;
+			else if (bPtr->altImage)
+				image = bPtr->altImage;
+			if (bPtr->altTextColor)
+				textColor = bPtr->altTextColor;
+		}
+
+		if (bPtr->flags.statePush && bPtr->flags.bordered) {
+			relief = WRSunken;
+			offset = 1;
+		}
+	}
+
+	if (bPtr->flags.pushed) {
+		if (bPtr->flags.pushIn) {
+			relief = WRPushed;
+			offset = 1;
+		}
+		if (bPtr->flags.pushLight) {
+			backColor = scrPtr->white;
+			textColor = scrPtr->black;
+		}
+
+		if (bPtr->flags.pushChange) {
+			if (bPtr->altCaption)
+				caption = bPtr->altCaption;
+			if (bPtr->altImage)
+				image = bPtr->altImage;
+			if (bPtr->altTextColor)
+				textColor = bPtr->altTextColor;
+		}
+	}
+
+	W_PaintTextAndImage(bPtr->view, True, textColor,
+			    (bPtr->font != NULL ? bPtr->font : scrPtr->normalFont),
+			    relief, caption, bPtr->flags.alignment, image,
+			    bPtr->flags.imagePosition, backColor, offset);
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	Button *bPtr = (Button *) data;
+
+	CHECK_CLASS(data, WC_Button);
+
+	switch (event->type) {
+	case Expose:
+		if (event->xexpose.count != 0)
+			break;
+		paintButton(bPtr);
+		break;
+
+	case DestroyNotify:
+		destroyButton(bPtr);
+		break;
+	}
+}
+
+static void autoRepeat(void *data)
+{
+	Button *bPtr = (Button *) data;
+
+	if (bPtr->action && bPtr->flags.pushed)
+		(*bPtr->action) (bPtr, bPtr->clientData);
+
+	bPtr->timer = WMAddTimerHandler((int)(bPtr->periodicInterval * 1000), autoRepeat, bPtr);
+}
+
+static void handleActionEvents(XEvent * event, void *data)
+{
+	Button *bPtr = (Button *) data;
+	int doclick = 0, dopaint = 0;
+
+	CHECK_CLASS(data, WC_Button);
+
+	if (!bPtr->flags.enabled)
+		return;
+
+	switch (event->type) {
+	case EnterNotify:
+		if (bPtr->groupIndex == 0) {
+			bPtr->flags.pushed = bPtr->flags.wasPushed;
+			if (bPtr->flags.pushed) {
+				bPtr->flags.selected = !bPtr->flags.prevSelected;
+				dopaint = 1;
+			}
+		}
+		break;
+
+	case LeaveNotify:
+		if (bPtr->groupIndex == 0) {
+			bPtr->flags.wasPushed = bPtr->flags.pushed;
+			if (bPtr->flags.pushed) {
+				bPtr->flags.selected = bPtr->flags.prevSelected;
+				dopaint = 1;
+			}
+			bPtr->flags.pushed = 0;
+		}
+		break;
+
+	case ButtonPress:
+		if (event->xbutton.button == Button1) {
+			static const unsigned int next_state[4] = { [0] = 1, [1] = 2, [2] = 0 };
+
+			bPtr->flags.prevSelected = bPtr->flags.selected;
+			bPtr->flags.wasPushed = 0;
+			bPtr->flags.pushed = 1;
+			if (bPtr->groupIndex > 0) {
+				bPtr->flags.selected = 1;
+				dopaint = 1;
+				break;
+			}
+			if (bPtr->flags.type == WBTTriState)
+				bPtr->flags.selected = next_state[bPtr->flags.selected];
+			else
+				bPtr->flags.selected = !bPtr->flags.selected;
+			dopaint = 1;
+
+			if (bPtr->flags.continuous && !bPtr->timer) {
+				bPtr->timer = WMAddTimerHandler((int)(bPtr->periodicDelay * 1000),
+								autoRepeat, bPtr);
+			}
+		}
+		break;
+
+	case ButtonRelease:
+		if (event->xbutton.button == Button1) {
+			if (bPtr->flags.pushed) {
+				if (bPtr->groupIndex == 0 || (bPtr->flags.selected && bPtr->groupIndex > 0))
+					doclick = 1;
+				dopaint = 1;
+				if (bPtr->flags.springLoaded) {
+					bPtr->flags.selected = bPtr->flags.prevSelected;
+				}
+			}
+			bPtr->flags.pushed = 0;
+		}
+		if (bPtr->timer) {
+			WMDeleteTimerHandler(bPtr->timer);
+			bPtr->timer = NULL;
+		}
+		break;
+	}
+
+	if (dopaint)
+		paintButton(bPtr);
+
+	if (doclick) {
+		if (bPtr->flags.selected && bPtr->groupIndex > 0) {
+			WMPostNotificationName(WMPushedRadioNotification, bPtr, NULL);
+		}
+
+		if (bPtr->action)
+			(*bPtr->action) (bPtr, bPtr->clientData);
+	}
+}
+
+static void destroyButton(Button * bPtr)
+{
+	if (bPtr->flags.addedObserver) {
+		WMRemoveNotificationObserver(bPtr);
+	}
+
+	if (bPtr->timer)
+		WMDeleteTimerHandler(bPtr->timer);
+
+	if (bPtr->font)
+		WMReleaseFont(bPtr->font);
+
+	if (bPtr->caption)
+		wfree(bPtr->caption);
+
+	if (bPtr->altCaption)
+		wfree(bPtr->altCaption);
+
+	if (bPtr->textColor)
+		WMReleaseColor(bPtr->textColor);
+
+	if (bPtr->altTextColor)
+		WMReleaseColor(bPtr->altTextColor);
+
+	if (bPtr->disTextColor)
+		WMReleaseColor(bPtr->disTextColor);
+
+	if (bPtr->image)
+		WMReleasePixmap(bPtr->image);
+
+	if (bPtr->dimage) {
+		/* yuck.. kluge */
+		bPtr->dimage->pixmap = None;
+
+		WMReleasePixmap(bPtr->dimage);
+	}
+	if (bPtr->altImage)
+		WMReleasePixmap(bPtr->altImage);
+
+	if (bPtr->tsImage)
+		WMReleasePixmap(bPtr->tsImage);
+
+	wfree(bPtr);
+}

bazel/WINGs/wcolor.c

@@ -0,0 +1,326 @@
+
+#include "WINGs/WINGsP.h"
+
+#include "wconfig.h"
+
+#include "wrlib/wraster.h"
+
+#define LIGHT_STIPPLE_WIDTH 4
+#define LIGHT_STIPPLE_HEIGHT 4
+static char LIGHT_STIPPLE_BITS[] = {
+	0x05, 0x0a, 0x05, 0x0a
+};
+
+#define DARK_STIPPLE_WIDTH 4
+#define DARK_STIPPLE_HEIGHT 4
+static char DARK_STIPPLE_BITS[] = {
+	0x0a, 0x04, 0x0a, 0x01
+};
+
+static WMColor *createRGBAColor(WMScreen * scr, unsigned short red,
+				unsigned short green, unsigned short blue, unsigned short alpha);
+
+/*
+ * TODO: make the color creation code return the same WMColor for the
+ * same colors.
+ * make findCloseColor() find the closest color in the RContext pallette
+ * or in the other colors allocated by WINGs.
+ */
+
+static WMColor *findCloseColor(WMScreen * scr, unsigned short red, unsigned short green,
+			       unsigned short blue, unsigned short alpha)
+{
+	WMColor *color;
+	XColor xcolor;
+	RColor rcolor;
+
+	rcolor.red = red >> 8;
+	rcolor.green = green >> 8;
+	rcolor.blue = blue >> 8;
+	rcolor.alpha = alpha >> 8;
+
+	if (!RGetClosestXColor(scr->rcontext, &rcolor, &xcolor))
+		return NULL;
+
+	if (!XAllocColor(scr->display, scr->colormap, &xcolor))
+		return NULL;
+
+	color = wmalloc(sizeof(WMColor));
+
+	color->screen = scr;
+	color->refCount = 1;
+	color->color = xcolor;
+	color->alpha = alpha;
+	color->flags.exact = 0;
+	color->gc = NULL;
+
+	return color;
+}
+
+static WMColor *createRGBAColor(WMScreen * scr, unsigned short red, unsigned short green,
+				unsigned short blue, unsigned short alpha)
+{
+	WMColor *color;
+	XColor xcolor;
+
+	xcolor.red = red;
+	xcolor.green = green;
+	xcolor.blue = blue;
+	xcolor.flags = DoRed | DoGreen | DoBlue;
+	if (!XAllocColor(scr->display, scr->colormap, &xcolor))
+		return NULL;
+
+	color = wmalloc(sizeof(WMColor));
+
+	color->screen = scr;
+	color->refCount = 1;
+	color->color = xcolor;
+	color->alpha = alpha;
+	color->flags.exact = 1;
+	color->gc = NULL;
+
+	return color;
+}
+
+WMColor *WMCreateRGBColor(WMScreen * scr, unsigned short red, unsigned short green,
+			  unsigned short blue, Bool exact)
+{
+	WMColor *color = NULL;
+
+	if (!exact || !(color = createRGBAColor(scr, red, green, blue, 0xffff))) {
+		color = findCloseColor(scr, red, green, blue, 0xffff);
+	}
+	if (!color)
+		color = scr->black;
+
+	return color;
+}
+
+RColor WMGetRColorFromColor(WMColor * color)
+{
+	RColor rcolor;
+
+	rcolor.red = color->color.red >> 8;
+	rcolor.green = color->color.green >> 8;
+	rcolor.blue = color->color.blue >> 8;
+	rcolor.alpha = color->alpha >> 8;
+
+	return rcolor;
+}
+
+WMColor *WMCreateRGBAColor(WMScreen * scr, unsigned short red, unsigned short green,
+			   unsigned short blue, unsigned short alpha, Bool exact)
+{
+	WMColor *color = NULL;
+
+	if (!exact || !(color = createRGBAColor(scr, red, green, blue, alpha))) {
+		color = findCloseColor(scr, red, green, blue, alpha);
+	}
+	if (!color)
+		color = scr->black;
+
+	return color;
+}
+
+WMColor *WMCreateNamedColor(WMScreen * scr, const char *name, Bool exact)
+{
+	WMColor *color;
+	XColor xcolor;
+
+	if (!XParseColor(scr->display, scr->colormap, name, &xcolor))
+		return NULL;
+
+	if (scr->visual->class == TrueColor)
+		exact = True;
+
+	if (!exact || !(color = createRGBAColor(scr, xcolor.red, xcolor.green, xcolor.blue, 0xffff))) {
+		color = findCloseColor(scr, xcolor.red, xcolor.green, xcolor.blue, 0xffff);
+	}
+	return color;
+}
+
+WMColor *WMRetainColor(WMColor * color)
+{
+	assert(color != NULL);
+
+	color->refCount++;
+
+	return color;
+}
+
+void WMReleaseColor(WMColor * color)
+{
+	color->refCount--;
+
+	if (color->refCount < 1) {
+		XFreeColors(color->screen->display, color->screen->colormap, &(color->color.pixel), 1, 0);
+		if (color->gc)
+			XFreeGC(color->screen->display, color->gc);
+		wfree(color);
+	}
+}
+
+void WMSetColorAlpha(WMColor * color, unsigned short alpha)
+{
+	color->alpha = alpha;
+}
+
+void WMPaintColorSwatch(WMColor * color, Drawable d, int x, int y, unsigned int width, unsigned int height)
+{
+	XFillRectangle(color->screen->display, d, WMColorGC(color), x, y, width, height);
+}
+
+WMPixel WMColorPixel(WMColor * color)
+{
+	return color->color.pixel;
+}
+
+GC WMColorGC(WMColor * color)
+{
+	if (!color->gc) {
+		XGCValues gcv;
+		WMScreen *scr = color->screen;
+
+		gcv.foreground = color->color.pixel;
+		gcv.graphics_exposures = False;
+		color->gc = XCreateGC(scr->display, scr->rcontext->drawable,
+				      GCForeground | GCGraphicsExposures, &gcv);
+	}
+
+	return color->gc;
+}
+
+void WMSetColorInGC(WMColor * color, GC gc)
+{
+	XSetForeground(color->screen->display, gc, color->color.pixel);
+}
+
+/* "system" colors */
+WMColor *WMWhiteColor(WMScreen * scr)
+{
+	if (!scr->white) {
+		scr->white = WMCreateRGBColor(scr, 0xffff, 0xffff, 0xffff, True);
+		if (!scr->white->flags.exact)
+			wwarning(_("could not allocate %s color"), _("white"));
+	}
+	return WMRetainColor(scr->white);
+}
+
+WMColor *WMBlackColor(WMScreen * scr)
+{
+	if (!scr->black) {
+		scr->black = WMCreateRGBColor(scr, 0, 0, 0, True);
+		if (!scr->black->flags.exact)
+			wwarning(_("could not allocate %s color"), _("black"));
+	}
+	return WMRetainColor(scr->black);
+}
+
+WMColor *WMGrayColor(WMScreen * scr)
+{
+	if (!scr->gray) {
+		WMColor *color;
+
+		if (scr->depth == 1) {
+			Pixmap stipple;
+			WMColor *white = WMWhiteColor(scr);
+			WMColor *black = WMBlackColor(scr);
+			XGCValues gcv;
+
+			stipple = XCreateBitmapFromData(scr->display, W_DRAWABLE(scr),
+							LIGHT_STIPPLE_BITS, LIGHT_STIPPLE_WIDTH,
+							LIGHT_STIPPLE_HEIGHT);
+
+			color = createRGBAColor(scr, 0xffff, 0xffff, 0xffff, 0xffff);
+
+			gcv.foreground = white->color.pixel;
+			gcv.background = black->color.pixel;
+			gcv.fill_style = FillStippled;
+			gcv.stipple = stipple;
+			color->gc = XCreateGC(scr->display, W_DRAWABLE(scr), GCForeground
+					      | GCBackground | GCStipple | GCFillStyle
+					      | GCGraphicsExposures, &gcv);
+
+			XFreePixmap(scr->display, stipple);
+			WMReleaseColor(white);
+			WMReleaseColor(black);
+		} else {
+			color = WMCreateRGBColor(scr, 0xaeba, 0xaaaa, 0xaeba, True);
+			if (!color->flags.exact)
+				wwarning(_("could not allocate %s color"), _("gray"));
+		}
+		scr->gray = color;
+	}
+	return WMRetainColor(scr->gray);
+}
+
+WMColor *WMDarkGrayColor(WMScreen * scr)
+{
+	if (!scr->darkGray) {
+		WMColor *color;
+
+		if (scr->depth == 1) {
+			Pixmap stipple;
+			WMColor *white = WMWhiteColor(scr);
+			WMColor *black = WMBlackColor(scr);
+			XGCValues gcv;
+
+			stipple = XCreateBitmapFromData(scr->display, W_DRAWABLE(scr),
+							DARK_STIPPLE_BITS, DARK_STIPPLE_WIDTH,
+							DARK_STIPPLE_HEIGHT);
+
+			color = createRGBAColor(scr, 0, 0, 0, 0xffff);
+
+			gcv.foreground = white->color.pixel;
+			gcv.background = black->color.pixel;
+			gcv.fill_style = FillStippled;
+			gcv.stipple = stipple;
+			color->gc = XCreateGC(scr->display, W_DRAWABLE(scr), GCForeground
+					      | GCBackground | GCStipple | GCFillStyle
+					      | GCGraphicsExposures, &gcv);
+
+			XFreePixmap(scr->display, stipple);
+			WMReleaseColor(white);
+			WMReleaseColor(black);
+		} else {
+			color = WMCreateRGBColor(scr, 0x5144, 0x5555, 0x5144, True);
+			if (!color->flags.exact)
+				wwarning(_("could not allocate %s color"), _("dark gray"));
+		}
+		scr->darkGray = color;
+	}
+	return WMRetainColor(scr->darkGray);
+}
+
+unsigned short WMRedComponentOfColor(WMColor * color)
+{
+	return color->color.red;
+}
+
+unsigned short WMGreenComponentOfColor(WMColor * color)
+{
+	return color->color.green;
+}
+
+unsigned short WMBlueComponentOfColor(WMColor * color)
+{
+	return color->color.blue;
+}
+
+unsigned short WMGetColorAlpha(WMColor * color)
+{
+	return color->alpha;
+}
+
+char *WMGetColorRGBDescription(WMColor * color)
+{
+	char *str = wmalloc(8);
+
+	if (snprintf(str, 8, "#%02x%02x%02x",
+		     color->color.red >> 8, color->color.green >> 8, color->color.blue >> 8) >= 8) {
+		wfree(str);
+		return NULL;
+	}
+
+	return str;
+}

bazel/WINGs/wcolorwell.c

@@ -0,0 +1,417 @@
+
+#include "WINGs/WINGsP.h"
+
+#define XDND_COLOR_DATA_TYPE "application/X-color"
+
+const char *WMColorWellDidChangeNotification = "WMColorWellDidChangeNotification";
+
+typedef struct W_ColorWell {
+	W_Class widgetClass;
+	WMView *view;
+
+	WMView *colorView;
+
+	WMColor *color;
+
+	WMAction *action;
+	void *clientData;
+
+	WMPoint ipoint;
+
+	struct {
+		unsigned int active:1;
+		unsigned int bordered:1;
+	} flags;
+
+	WMArray *xdndTypes;
+} ColorWell;
+
+static char *_ColorWellActivatedNotification = "_ColorWellActivatedNotification";
+
+static void destroyColorWell(ColorWell * cPtr);
+static void paintColorWell(ColorWell * cPtr);
+
+static void handleEvents(XEvent * event, void *data);
+
+static void handleDragEvents(XEvent * event, void *data);
+
+static void handleActionEvents(XEvent * event, void *data);
+
+static void willResizeColorWell(W_ViewDelegate * self, WMView * view, unsigned int *width, unsigned int *height);
+
+W_ViewDelegate _ColorWellViewDelegate = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	willResizeColorWell
+};
+
+static WMArray *dropDataTypes(WMView * self);
+static WMDragOperationType wantedDropOperation(WMView * self);
+static Bool acceptDropOperation(WMView * self, WMDragOperationType operation);
+static WMData *fetchDragData(WMView * self, char *type);
+
+static WMDragSourceProcs _DragSourceProcs = {
+	dropDataTypes,
+	wantedDropOperation,
+	NULL,
+	acceptDropOperation,
+	NULL,
+	NULL,
+	fetchDragData
+};
+
+static WMArray *requiredDataTypes(WMView * self,
+				  WMDragOperationType requestedOperation, WMArray * sourceDataTypes);
+static WMDragOperationType allowedOperation(WMView * self,
+					    WMDragOperationType requestedOperation, WMArray * sourceDataTypes);
+static void performDragOperation(WMView * self, WMArray * dropDatas,
+				 WMArray * operationsList, WMPoint * dropLocation);
+
+static WMDragDestinationProcs _DragDestinationProcs = {
+	NULL,
+	requiredDataTypes,
+	allowedOperation,
+	NULL,
+	performDragOperation,
+	NULL
+};
+
+#define DEFAULT_WIDTH		60
+#define DEFAULT_HEIGHT		30
+
+#define MIN_WIDTH	16
+#define MIN_HEIGHT	8
+
+static void colorChangedObserver(void *data, WMNotification * notification)
+{
+	WMColorPanel *panel = (WMColorPanel *) WMGetNotificationObject(notification);
+	WMColorWell *cPtr = (WMColorWell *) data;
+	WMColor *color;
+
+	if (!cPtr->flags.active)
+		return;
+
+	color = WMGetColorPanelColor(panel);
+
+	WMSetColorWellColor(cPtr, color);
+	WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
+}
+
+static void updateColorCallback(void *self, void *data)
+{
+	WMColorPanel *panel = (WMColorPanel *) self;
+	WMColorWell *cPtr = (ColorWell *) data;
+	WMColor *color;
+
+	color = WMGetColorPanelColor(panel);
+	WMSetColorWellColor(cPtr, color);
+	WMPostNotificationName(WMColorWellDidChangeNotification, cPtr, NULL);
+}
+
+static WMArray *getXdndTypeArray(void)
+{
+	WMArray *types = WMCreateArray(1);
+	WMAddToArray(types, XDND_COLOR_DATA_TYPE);
+	return types;
+}
+
+WMColorWell *WMCreateColorWell(WMWidget * parent)
+{
+	ColorWell *cPtr;
+
+	cPtr = wmalloc(sizeof(ColorWell));
+
+	cPtr->widgetClass = WC_ColorWell;
+
+	cPtr->view = W_CreateView(W_VIEW(parent));
+	if (!cPtr->view) {
+		wfree(cPtr);
+		return NULL;
+	}
+	cPtr->view->self = cPtr;
+
+	cPtr->view->delegate = &_ColorWellViewDelegate;
+
+	cPtr->colorView = W_CreateView(cPtr->view);
+	if (!cPtr->colorView) {
+		W_DestroyView(cPtr->view);
+		wfree(cPtr);
+		return NULL;
+	}
+	cPtr->colorView->self = cPtr;
+
+	WMCreateEventHandler(cPtr->view, ExposureMask | StructureNotifyMask
+			     | ClientMessageMask, handleEvents, cPtr);
+
+	WMCreateEventHandler(cPtr->colorView, ExposureMask, handleEvents, cPtr);
+
+	WMCreateDragHandler(cPtr->colorView, handleDragEvents, cPtr);
+
+	WMCreateEventHandler(cPtr->view, ButtonPressMask, handleActionEvents, cPtr);
+	WMCreateEventHandler(cPtr->colorView, ButtonPressMask, handleActionEvents, cPtr);
+
+	cPtr->colorView->flags.mapWhenRealized = 1;
+
+	cPtr->flags.bordered = 1;
+
+	W_ResizeView(cPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+
+	cPtr->color = WMBlackColor(WMWidgetScreen(cPtr));
+
+	WMAddNotificationObserver(colorChangedObserver, cPtr, WMColorPanelColorChangedNotification, NULL);
+
+	WMSetViewDragSourceProcs(cPtr->colorView, &_DragSourceProcs);
+	WMSetViewDragDestinationProcs(cPtr->colorView, &_DragDestinationProcs);
+
+	cPtr->xdndTypes = getXdndTypeArray();
+	WMRegisterViewForDraggedTypes(cPtr->colorView, cPtr->xdndTypes);
+
+	return cPtr;
+}
+
+void WMSetColorWellColor(WMColorWell * cPtr, WMColor * color)
+{
+	if (cPtr->color && cPtr->color != color) {
+		WMReleaseColor(cPtr->color);
+		cPtr->color = WMRetainColor(color);
+	}
+
+	if (cPtr->colorView->flags.realized && cPtr->colorView->flags.mapped)
+		paintColorWell(cPtr);
+}
+
+WMColor *WMGetColorWellColor(WMColorWell * cPtr)
+{
+	return cPtr->color;
+}
+
+void WSetColorWellBordered(WMColorWell * cPtr, Bool flag)
+{
+	flag = ((flag == 0) ? 0 : 1);
+	if (cPtr->flags.bordered != flag) {
+		cPtr->flags.bordered = flag;
+		W_ResizeView(cPtr->view, cPtr->view->size.width, cPtr->view->size.height);
+	}
+}
+
+static void willResizeColorWell(W_ViewDelegate * self, WMView * view, unsigned int *width, unsigned int *height)
+{
+	WMColorWell *cPtr = (WMColorWell *) view->self;
+	int bw;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+
+	if (cPtr->flags.bordered) {
+
+		if (*width < MIN_WIDTH)
+			*width = MIN_WIDTH;
+		if (*height < MIN_HEIGHT)
+			*height = MIN_HEIGHT;
+
+		bw = (int)((float)WMIN(*width, *height) * 0.24F);
+
+		W_ResizeView(cPtr->colorView, *width - 2 * bw, *height - 2 * bw);
+
+		if (cPtr->colorView->pos.x != bw || cPtr->colorView->pos.y != bw)
+			W_MoveView(cPtr->colorView, bw, bw);
+	} else {
+		W_ResizeView(cPtr->colorView, *width, *height);
+
+		W_MoveView(cPtr->colorView, 0, 0);
+	}
+}
+
+static void paintColorWell(ColorWell * cPtr)
+{
+	W_Screen *scr = cPtr->view->screen;
+
+	W_DrawRelief(scr, cPtr->view->window, 0, 0, cPtr->view->size.width, cPtr->view->size.height, WRRaised);
+
+	W_DrawRelief(scr, cPtr->colorView->window, 0, 0,
+		     cPtr->colorView->size.width, cPtr->colorView->size.height, WRSunken);
+
+	if (cPtr->color)
+		WMPaintColorSwatch(cPtr->color, cPtr->colorView->window,
+				   2, 2, cPtr->colorView->size.width - 4, cPtr->colorView->size.height - 4);
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	ColorWell *cPtr = (ColorWell *) data;
+
+	CHECK_CLASS(data, WC_ColorWell);
+
+	switch (event->type) {
+	case Expose:
+		if (event->xexpose.count != 0)
+			break;
+		paintColorWell(cPtr);
+		break;
+
+	case DestroyNotify:
+		destroyColorWell(cPtr);
+		break;
+
+	}
+}
+
+static WMArray *dropDataTypes(WMView * self)
+{
+	return ((ColorWell *) self->self)->xdndTypes;
+}
+
+static WMDragOperationType wantedDropOperation(WMView * self)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+
+	return WDOperationCopy;
+}
+
+static Bool acceptDropOperation(WMView * self, WMDragOperationType operation)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+
+	return (operation == WDOperationCopy);
+}
+
+static WMData *fetchDragData(WMView * self, char *type)
+{
+	char *color = WMGetColorRGBDescription(((WMColorWell *) self->self)->color);
+	WMData *data;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) type;
+
+	data = WMCreateDataWithBytes(color, strlen(color) + 1);
+	wfree(color);
+
+	return data;
+}
+
+static WMPixmap *makeDragPixmap(WMColorWell * cPtr)
+{
+	WMScreen *scr = cPtr->view->screen;
+	Pixmap pix;
+
+	pix = XCreatePixmap(scr->display, W_DRAWABLE(scr), 16, 16, scr->depth);
+
+	XFillRectangle(scr->display, pix, WMColorGC(cPtr->color), 0, 0, 15, 15);
+
+	XDrawRectangle(scr->display, pix, WMColorGC(scr->black), 0, 0, 15, 15);
+
+	return WMCreatePixmapFromXPixmaps(scr, pix, None, 16, 16, scr->depth);
+}
+
+static void handleDragEvents(XEvent * event, void *data)
+{
+	WMColorWell *cPtr = (ColorWell *) data;
+
+	if (event->type == ButtonPress && event->xbutton.button == Button1) {
+		/* initialise drag icon */
+		WMSetViewDragImage(cPtr->colorView, makeDragPixmap(cPtr));
+	}
+
+	WMDragImageFromView(cPtr->colorView, event);
+}
+
+static void handleActionEvents(XEvent * event, void *data)
+{
+	WMColorWell *cPtr = (ColorWell *) data;
+	WMScreen *scr = WMWidgetScreen(cPtr);
+	WMColorPanel *cpanel;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) event;
+
+	if (cPtr->flags.active)
+		W_SetViewBackgroundColor(cPtr->view, scr->gray);
+	else
+		W_SetViewBackgroundColor(cPtr->view, scr->white);
+	paintColorWell(cPtr);
+
+	cPtr->flags.active ^= 1;
+
+	if (cPtr->flags.active) {
+		WMPostNotificationName(_ColorWellActivatedNotification, cPtr, NULL);
+	}
+	cpanel = WMGetColorPanel(scr);
+
+	WMSetColorPanelAction(cpanel, updateColorCallback, cPtr);
+
+	if (cPtr->color)
+		WMSetColorPanelColor(cpanel, cPtr->color);
+	WMShowColorPanel(cpanel);
+}
+
+static void destroyColorWell(ColorWell * cPtr)
+{
+	WMRemoveNotificationObserver(cPtr);
+
+	if (cPtr->color)
+		WMReleaseColor(cPtr->color);
+
+	WMFreeArray(cPtr->xdndTypes);
+
+	wfree(cPtr);
+}
+
+static Bool dropIsOk(WMDragOperationType request, WMArray * sourceDataTypes)
+{
+	WMArrayIterator iter;
+	char *type;
+
+	if (request == WDOperationCopy) {
+		WM_ITERATE_ARRAY(sourceDataTypes, type, iter) {
+			if (type != NULL && strcmp(type, XDND_COLOR_DATA_TYPE) == 0) {
+				return True;
+			}
+		}
+	}
+
+	return False;
+}
+
+static WMArray *requiredDataTypes(WMView * self, WMDragOperationType request, WMArray * sourceDataTypes)
+{
+	if (dropIsOk(request, sourceDataTypes))
+		return ((ColorWell *) self->self)->xdndTypes;
+	else
+		return NULL;
+}
+
+static WMDragOperationType allowedOperation(WMView * self, WMDragOperationType request, WMArray * sourceDataTypes)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+
+	if (dropIsOk(request, sourceDataTypes))
+		return WDOperationCopy;
+	else
+		return WDOperationNone;
+}
+
+static void performDragOperation(WMView * self, WMArray * dropData, WMArray * operations, WMPoint * dropLocation)
+{
+	char *colorName;
+	WMColor *color;
+	WMData *data;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) operations;
+	(void) dropLocation;
+
+	/* only one operation requested (WDOperationCopy) implies only one data */
+	data = (WMData *) WMGetFromArray(dropData, 0);
+
+	if (data != NULL) {
+		colorName = (char *)WMDataBytes(data);
+		color = WMCreateNamedColor(W_VIEW_SCREEN(self), colorName, True);
+		WMSetColorWellColor(self->self, color);
+		WMReleaseColor(color);
+	}
+}

bazel/WINGs/wconfig.h

@@ -0,0 +1,42 @@
+/* wconfig.h
+ *
+ *  Copyright (c) 2001 Dan Pascu
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef WINGS_CONFIG_H_
+#define WINGS_CONFIG_H_
+
+#include "config/config.h"
+
+#include <stdlib.h>
+
+#if defined(HAVE_LIBINTL_H) && defined(I18N)
+# include <libintl.h>
+# define _(text) dgettext("WINGs", text)
+#else
+# define _(text) (text)
+#endif
+
+#ifdef HAVE_SECURE_GETENV
+#define GETENV(x) secure_getenv((x))
+#else
+#define GETENV(x) getenv((x))
+#endif
+
+
+#endif /* WINGS_CONFIG_H_ */
+

bazel/WINGs/wevent.c

@@ -0,0 +1,431 @@
+
+/*
+ * This event handling stuff was inspired on Tk.
+ */
+
+#include "WINGs/WINGsP.h"
+
+/* table to map event types to event masks */
+static const unsigned long eventMasks[] = {
+	0,
+	0,
+	KeyPressMask,		/* KeyPress */
+	KeyReleaseMask,		/* KeyRelease */
+	ButtonPressMask,	/* ButtonPress */
+	ButtonReleaseMask,	/* ButtonRelease */
+	PointerMotionMask | PointerMotionHintMask | ButtonMotionMask
+	    | Button1MotionMask | Button2MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask,
+	/* MotionNotify */
+	EnterWindowMask,	/* EnterNotify */
+	LeaveWindowMask,	/* LeaveNotify */
+	FocusChangeMask,	/* FocusIn */
+	FocusChangeMask,	/* FocusOut */
+	KeymapStateMask,	/* KeymapNotify */
+	ExposureMask,		/* Expose */
+	ExposureMask,		/* GraphicsExpose */
+	ExposureMask,		/* NoExpose */
+	VisibilityChangeMask,	/* VisibilityNotify */
+	SubstructureNotifyMask,	/* CreateNotify */
+	StructureNotifyMask,	/* DestroyNotify */
+	StructureNotifyMask,	/* UnmapNotify */
+	StructureNotifyMask,	/* MapNotify */
+	SubstructureRedirectMask,	/* MapRequest */
+	StructureNotifyMask,	/* ReparentNotify */
+	StructureNotifyMask,	/* ConfigureNotify */
+	SubstructureRedirectMask,	/* ConfigureRequest */
+	StructureNotifyMask,	/* GravityNotify */
+	ResizeRedirectMask,	/* ResizeRequest */
+	StructureNotifyMask,	/* CirculateNotify */
+	SubstructureRedirectMask,	/* CirculateRequest */
+	PropertyChangeMask,	/* PropertyNotify */
+	0,			/* SelectionClear */
+	0,			/* SelectionRequest */
+	0,			/* SelectionNotify */
+	ColormapChangeMask,	/* ColormapNotify */
+	ClientMessageMask,	/* ClientMessage */
+	0,			/* Mapping Notify */
+};
+
+/* hook for other toolkits or wmaker process their events */
+static WMEventHook *extraEventHandler = NULL;
+
+/*
+ * WMCreateEventHandler--
+ * 	Create an event handler and put it in the event handler list for the
+ * view. If the same callback and clientdata are already used in another
+ * handler, the masks are OR'ed.
+ *
+ */
+void WMCreateEventHandler(WMView * view, unsigned long mask, WMEventProc * eventProc, void *clientData)
+{
+	W_EventHandler *hPtr;
+	WMArrayIterator iter;
+
+	WM_ITERATE_ARRAY(view->eventHandlers, hPtr, iter) {
+		if (hPtr->clientData == clientData && hPtr->proc == eventProc) {
+			hPtr->eventMask |= mask;
+			return;
+		}
+	}
+
+	hPtr = wmalloc(sizeof(W_EventHandler));
+
+	/* select events for window */
+	hPtr->eventMask = mask;
+	hPtr->proc = eventProc;
+	hPtr->clientData = clientData;
+
+	WMAddToArray(view->eventHandlers, hPtr);
+}
+
+static int matchHandler(const void *item, const void *cdata)
+{
+	const W_EventHandler *h1 = item;
+	const W_EventHandler *h2 = cdata;
+
+	return ((h1->eventMask == h2->eventMask) &&
+			  (h1->proc == h2->proc) &&
+			  (h1->clientData == h2->clientData));
+}
+
+/*
+ * WMDeleteEventHandler--
+ * 	Delete event handler matching arguments from windows
+ * event handler list.
+ *
+ */
+void WMDeleteEventHandler(WMView * view, unsigned long mask, WMEventProc * eventProc, void *clientData)
+{
+	W_EventHandler tmp;
+
+	tmp.eventMask = mask;
+	tmp.proc = eventProc;
+	tmp.clientData = clientData;
+	WMRemoveFromArrayMatching(view->eventHandlers, matchHandler, (void *)&tmp);
+}
+
+static Time getEventTime(WMScreen * screen, XEvent * event)
+{
+	switch (event->type) {
+	case ButtonPress:
+	case ButtonRelease:
+		return event->xbutton.time;
+	case KeyPress:
+	case KeyRelease:
+		return event->xkey.time;
+	case MotionNotify:
+		return event->xmotion.time;
+	case EnterNotify:
+	case LeaveNotify:
+		return event->xcrossing.time;
+	case PropertyNotify:
+		return event->xproperty.time;
+	case SelectionClear:
+		return event->xselectionclear.time;
+	case SelectionRequest:
+		return event->xselectionrequest.time;
+	case SelectionNotify:
+		return event->xselection.time;
+	default:
+		return screen->lastEventTime;
+	}
+}
+
+void W_CallDestroyHandlers(W_View * view)
+{
+	XEvent event;
+	WMArrayIterator iter;
+	W_EventHandler *hPtr;
+
+	event.type = DestroyNotify;
+	event.xdestroywindow.window = view->window;
+	event.xdestroywindow.event = view->window;
+
+	WM_ITERATE_ARRAY(view->eventHandlers, hPtr, iter) {
+		if (hPtr->eventMask & StructureNotifyMask) {
+			(*hPtr->proc) (&event, hPtr->clientData);
+		}
+	}
+}
+
+void WMSetViewNextResponder(WMView * view, WMView * responder)
+{
+	/* set the widget to receive keyboard events that aren't handled
+	 * by this widget */
+
+	view->nextResponder = responder;
+}
+
+void WMRelayToNextResponder(WMView * view, XEvent * event)
+{
+	unsigned long mask = eventMasks[event->xany.type];
+
+	if (view->nextResponder) {
+		WMView *next = view->nextResponder;
+		W_EventHandler *hPtr;
+		WMArrayIterator iter;
+
+		WM_ITERATE_ARRAY(next->eventHandlers, hPtr, iter) {
+			if ((hPtr->eventMask & mask)) {
+				(*hPtr->proc) (event, hPtr->clientData);
+			}
+		}
+	}
+}
+
+int WMHandleEvent(XEvent * event)
+{
+	W_EventHandler *hPtr;
+	W_View *view, *toplevel;
+	unsigned long mask;
+	Window window;
+	WMArrayIterator iter;
+
+	if (event->type == MappingNotify) {
+		XRefreshKeyboardMapping(&event->xmapping);
+		return True;
+	}
+
+	if (XFilterEvent(event, None) == True) {
+		return False;
+	}
+
+	mask = eventMasks[event->xany.type];
+
+	window = event->xany.window;
+
+	/* diferentiate SubstructureNotify with StructureNotify */
+	if (mask == StructureNotifyMask) {
+		if (event->xmap.event != event->xmap.window) {
+			mask = SubstructureNotifyMask;
+			window = event->xmap.event;
+		}
+	}
+	view = W_GetViewForXWindow(event->xany.display, window);
+
+	if (!view) {
+		if (extraEventHandler)
+			(extraEventHandler) (event);
+
+		return False;
+	}
+
+	view->screen->lastEventTime = getEventTime(view->screen, event);
+
+	toplevel = W_TopLevelOfView(view);
+
+	if (event->type == SelectionNotify || event->type == SelectionClear || event->type == SelectionRequest) {
+		/* handle selection related events */
+		W_HandleSelectionEvent(event);
+
+	}
+
+	/* if it's a key event, redispatch it to the focused control */
+	if (mask & (KeyPressMask | KeyReleaseMask)) {
+		W_View *focused = W_FocusedViewOfToplevel(toplevel);
+
+		if (focused) {
+			view = focused;
+		}
+	}
+
+	/* compress Motion events */
+	if (event->type == MotionNotify && !view->flags.dontCompressMotion) {
+		while (XPending(event->xmotion.display)) {
+			XEvent ev;
+			XPeekEvent(event->xmotion.display, &ev);
+			if (ev.type == MotionNotify
+			    && event->xmotion.window == ev.xmotion.window
+			    && event->xmotion.subwindow == ev.xmotion.subwindow) {
+				/* replace events */
+				XNextEvent(event->xmotion.display, event);
+			} else
+				break;
+		}
+	}
+
+	/* compress expose events */
+	if (event->type == Expose && !view->flags.dontCompressExpose) {
+		while (XCheckTypedWindowEvent(event->xexpose.display, view->window, Expose, event)) ;
+	}
+
+	if (view->screen->modalLoop && toplevel != view->screen->modalView && !toplevel->flags.worksWhenModal) {
+		if (event->type == KeyPress || event->type == KeyRelease
+		    || event->type == MotionNotify || event->type == ButtonPress
+		    || event->type == ButtonRelease || event->type == FocusIn || event->type == FocusOut) {
+			return True;
+		}
+	}
+
+	/* do balloon stuffs */
+	if (event->type == EnterNotify)
+		W_BalloonHandleEnterView(view);
+	else if (event->type == LeaveNotify)
+		W_BalloonHandleLeaveView(view);
+
+	/* This is a hack. It will make the panel be secure while
+	 * the event handlers are handled, as some event handler
+	 * might destroy the widget. */
+	W_RetainView(toplevel);
+
+	WM_ITERATE_ARRAY(view->eventHandlers, hPtr, iter) {
+		if ((hPtr->eventMask & mask)) {
+			(*hPtr->proc) (event, hPtr->clientData);
+		}
+	}
+#if 0
+	/* pass the event to the top level window of the widget */
+	/* TODO: change this to a responder chain */
+	if (view->parent != NULL) {
+		vPtr = view;
+		while (vPtr->parent != NULL)
+			vPtr = vPtr->parent;
+
+		WM_ITERATE_ARRAY(vPtr->eventHandlers, hPtr, iter) {
+			if (hPtr->eventMask & mask) {
+				(*hPtr->proc) (event, hPtr->clientData);
+			}
+		}
+	}
+#endif
+	/* save button click info to track double-clicks */
+	if (view->screen->ignoreNextDoubleClick) {
+		view->screen->ignoreNextDoubleClick = 0;
+	} else {
+		if (event->type == ButtonPress) {
+			view->screen->lastClickWindow = event->xbutton.window;
+			view->screen->lastClickTime = event->xbutton.time;
+		}
+	}
+
+	if (event->type == ClientMessage) {
+		/* must be handled at the end, for such message can destroy the view */
+		W_HandleDNDClientMessage(toplevel, &event->xclient);
+	}
+
+	W_ReleaseView(toplevel);
+
+	return True;
+}
+
+int WMIsDoubleClick(XEvent * event)
+{
+	W_View *view;
+
+	if (event->type != ButtonPress)
+		return False;
+
+	view = W_GetViewForXWindow(event->xany.display, event->xbutton.window);
+
+	if (!view)
+		return False;
+
+	if (view->screen->lastClickWindow != event->xbutton.window)
+		return False;
+
+	if (event->xbutton.time - view->screen->lastClickTime < WINGsConfiguration.doubleClickDelay) {
+		view->screen->lastClickTime = 0;
+		view->screen->lastClickWindow = None;
+		view->screen->ignoreNextDoubleClick = 1;
+		return True;
+	} else
+		return False;
+}
+
+/*
+ * Check for X and input events. If X events are present input events will
+ * not be checked.
+ *
+ * Return value: True if a X event is available or any input event was
+ *               processed, false otherwise (including return because of
+ *               some timer handler expired).
+ *
+ *  If waitForInput is False, it will just peek for available input and return
+ * without processing. Return vaue will be True if input is available.
+ *
+ *  If waitForInput is True, it will wait until an input event arrives on the
+ * registered input handlers and ConnectionNumber(dpy), or will return when
+ * a timer handler expires if no input event arrived until then.
+ */
+static Bool waitForEvent(Display * dpy, unsigned long xeventmask, Bool waitForInput)
+{
+	XSync(dpy, False);
+	if (xeventmask == 0) {
+		if (XPending(dpy))
+			return True;
+	} else {
+		XEvent ev;
+		if (XCheckMaskEvent(dpy, xeventmask, &ev)) {
+			XPutBackEvent(dpy, &ev);
+			return True;
+		}
+	}
+
+	return W_HandleInputEvents(waitForInput, ConnectionNumber(dpy));
+}
+
+void WMNextEvent(Display * dpy, XEvent * event)
+{
+	/* Check any expired timers */
+	W_CheckTimerHandlers();
+
+	while (XPending(dpy) == 0) {
+		/* Do idle and timer stuff while there are no input or X events */
+		while (!waitForEvent(dpy, 0, False) && W_CheckIdleHandlers()) {
+			/* dispatch timer events */
+			W_CheckTimerHandlers();
+		}
+
+		/*
+		 * Make sure that new events did not arrive while we were doing
+		 * timer/idle stuff. Or we might block forever waiting for
+		 * an event that already arrived.
+		 */
+		/* wait for something to happen or a timer to expire */
+		waitForEvent(dpy, 0, True);
+
+		/* Check any expired timers */
+		W_CheckTimerHandlers();
+	}
+
+	XNextEvent(dpy, event);
+}
+
+void WMMaskEvent(Display * dpy, long mask, XEvent * event)
+{
+	/* Check any expired timers */
+	W_CheckTimerHandlers();
+
+	while (!XCheckMaskEvent(dpy, mask, event)) {
+		/* Do idle and timer stuff while there are no input or X events */
+		while (!waitForEvent(dpy, mask, False) && W_CheckIdleHandlers()) {
+			W_CheckTimerHandlers();
+		}
+
+		if (XCheckMaskEvent(dpy, mask, event))
+			return;
+
+		/* Wait for input on the X connection socket or another input handler */
+		waitForEvent(dpy, mask, True);
+
+		/* Check any expired timers */
+		W_CheckTimerHandlers();
+	}
+}
+
+Bool WMScreenPending(WMScreen * scr)
+{
+	if (XPending(scr->display))
+		return True;
+	else
+		return False;
+}
+
+WMEventHook *WMHookEventHandler(WMEventHook * handler)
+{
+	WMEventHook *oldHandler = extraEventHandler;
+
+	extraEventHandler = handler;
+
+	return oldHandler;
+}

bazel/WINGs/wfilepanel.c

@@ -0,0 +1,896 @@
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <unistd.h>
+#include <dirent.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdint.h>
+
+#include "WINGs/WINGsP.h"
+#include "WINGs/wconfig.h"
+
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+
+typedef struct W_FilePanel {
+	WMWindow *win;
+
+	WMLabel *iconLabel;
+	WMLabel *titleLabel;
+
+	WMFrame *line;
+
+	WMLabel *nameLabel;
+	WMBrowser *browser;
+
+	WMButton *okButton;
+	WMButton *cancelButton;
+
+	WMButton *homeButton;
+	WMButton *trashcanButton;
+	WMButton *createDirButton;
+	WMButton *disketteButton;
+	WMButton *unmountButton;
+
+	WMView *accessoryView;
+
+	WMTextField *fileField;
+
+	char **fileTypes;
+
+	struct {
+		unsigned int canExit:1;
+		unsigned int canceled:1;	/* clicked on cancel */
+		unsigned int filtered:1;
+		unsigned int canChooseFiles:1;
+		unsigned int canChooseDirectories:1;
+		unsigned int autoCompletion:1;
+		unsigned int showAllFiles:1;
+		unsigned int canFreeFileTypes:1;
+		unsigned int fileMustExist:1;
+		unsigned int panelType:1;
+	} flags;
+} W_FilePanel;
+
+/* Type of panel */
+#define WP_OPEN         0
+#define WP_SAVE         1
+
+#define PWIDTH		330
+#define PHEIGHT 	360
+
+static void listDirectoryOnColumn(WMFilePanel * panel, int column, const char *path);
+static void browserClick(WMWidget *widget, void *p_panel);
+static void browserDClick(WMWidget *widget, void *p_panel);
+
+static void fillColumn(WMBrowserDelegate * self, WMBrowser * bPtr, int column, WMList * list);
+
+static void normalizePath(char *s);
+
+static void deleteFile(WMWidget *widget, void *p_panel);
+static void createDir(WMWidget *widget, void *p_panel);
+static void goHome(WMWidget *widget, void *p_panel);
+static void goFloppy(WMWidget *widget, void *p_panel);
+static void goUnmount(WMWidget *widget, void *p_panel);
+static void buttonClick(WMWidget *widget, void *p_panel);
+
+static char *getCurrentFileName(WMFilePanel * panel);
+
+static void handleEvents(XEvent * event, void *data);
+
+static WMBrowserDelegate browserDelegate = {
+	NULL,			/* data */
+	fillColumn,		/* createRowsForColumn */
+	NULL,			/* titleOfColumn */
+	NULL,			/* didScroll */
+	NULL			/* willScroll */
+};
+
+static int closestListItem(WMList * list, const char *text, Bool exact)
+{
+	WMListItem *item;
+	WMArray *items = WMGetListItems(list);
+	int i, nb_item, len = strlen(text);
+
+	if (len == 0)
+		return -1;
+
+	nb_item = WMGetArrayItemCount(items);
+	for (i = 0; i < nb_item; i++) {
+		item = WMGetFromArray(items, i);
+		if ((exact && strcmp(item->text, text) == 0) ||
+			 (!exact && strncmp(item->text, text, len) == 0)) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+static void textChangedObserver(void *observerData, WMNotification * notification)
+{
+	W_FilePanel *panel = (W_FilePanel *) observerData;
+	char *text;
+	WMList *list;
+	int col = WMGetBrowserNumberOfColumns(panel->browser) - 1;
+	int i;
+	uintptr_t textEvent;
+
+	if (!(list = WMGetBrowserListInColumn(panel->browser, col)))
+		return;
+
+	text = WMGetTextFieldText(panel->fileField);
+	textEvent = (uintptr_t)WMGetNotificationClientData(notification);
+
+	if (panel->flags.autoCompletion && textEvent != WMDeleteTextEvent)
+		i = closestListItem(list, text, False);
+	else
+		i = closestListItem(list, text, True);
+
+	WMSelectListItem(list, i);
+	if (i >= 0 && panel->flags.autoCompletion) {
+		WMListItem *item = WMGetListItem(list, i);
+		int textLen = strlen(text), itemTextLen = strlen(item->text);
+		int visibleItems = WMWidgetHeight(list) / WMGetListItemHeight(list);
+
+		WMSetListPosition(list, i - visibleItems / 2);
+
+		if (textEvent != WMDeleteTextEvent) {
+			WMRange range;
+
+			WMInsertTextFieldText(panel->fileField, &item->text[textLen], textLen);
+			range.position = textLen;
+			range.count = itemTextLen - textLen;
+			WMSelectTextFieldRange(panel->fileField, range);
+			/*WMSetTextFieldCursorPosition(panel->fileField, itemTextLen); */
+		}
+	}
+
+	wfree(text);
+}
+
+static void textEditedObserver(void *observerData, WMNotification * notification)
+{
+	W_FilePanel *panel = (W_FilePanel *) observerData;
+
+	if ((uintptr_t)WMGetNotificationClientData(notification) == WMReturnTextMovement) {
+		WMPerformButtonClick(panel->okButton);
+	}
+}
+
+static WMFilePanel *makeFilePanel(WMScreen * scrPtr, const char *name, const char *title)
+{
+	WMFilePanel *fPtr;
+	WMFont *largeFont;
+	WMPixmap *icon;
+
+	fPtr = wmalloc(sizeof(WMFilePanel));
+
+	fPtr->win = WMCreateWindowWithStyle(scrPtr, name, WMTitledWindowMask | WMResizableWindowMask);
+	WMResizeWidget(fPtr->win, PWIDTH, PHEIGHT);
+	WMSetWindowTitle(fPtr->win, "");
+
+	WMCreateEventHandler(WMWidgetView(fPtr->win), StructureNotifyMask, handleEvents, fPtr);
+	WMSetWindowMinSize(fPtr->win, PWIDTH, PHEIGHT);
+
+	fPtr->iconLabel = WMCreateLabel(fPtr->win);
+	WMResizeWidget(fPtr->iconLabel, 64, 64);
+	WMMoveWidget(fPtr->iconLabel, 0, 0);
+	WMSetLabelImagePosition(fPtr->iconLabel, WIPImageOnly);
+	icon = WMCreateApplicationIconBlendedPixmap(scrPtr, (RColor *) NULL);
+	if (icon) {
+		WMSetLabelImage(fPtr->iconLabel, icon);
+		WMReleasePixmap(icon);
+	} else {
+		WMSetLabelImage(fPtr->iconLabel, scrPtr->applicationIconPixmap);
+	}
+
+	fPtr->titleLabel = WMCreateLabel(fPtr->win);
+	WMResizeWidget(fPtr->titleLabel, PWIDTH - 64, 64);
+	WMMoveWidget(fPtr->titleLabel, 64, 0);
+	largeFont = WMBoldSystemFontOfSize(scrPtr, 24);
+	WMSetLabelFont(fPtr->titleLabel, largeFont);
+	WMReleaseFont(largeFont);
+	WMSetLabelText(fPtr->titleLabel, title);
+
+	fPtr->line = WMCreateFrame(fPtr->win);
+	WMMoveWidget(fPtr->line, 0, 64);
+	WMResizeWidget(fPtr->line, PWIDTH, 2);
+	WMSetFrameRelief(fPtr->line, WRGroove);
+
+	fPtr->browser = WMCreateBrowser(fPtr->win);
+	WMSetBrowserAllowEmptySelection(fPtr->browser, True);
+	WMSetBrowserDelegate(fPtr->browser, &browserDelegate);
+	WMSetBrowserAction(fPtr->browser, browserClick, fPtr);
+	WMSetBrowserDoubleAction(fPtr->browser, browserDClick, fPtr);
+	WMMoveWidget(fPtr->browser, 7, 72);
+	WMResizeWidget(fPtr->browser, PWIDTH - 14, 200);
+	WMHangData(fPtr->browser, fPtr);
+
+	fPtr->nameLabel = WMCreateLabel(fPtr->win);
+	WMMoveWidget(fPtr->nameLabel, 7, 282);
+	WMResizeWidget(fPtr->nameLabel, 55, 14);
+	WMSetLabelText(fPtr->nameLabel, _("Name:"));
+
+	fPtr->fileField = WMCreateTextField(fPtr->win);
+	WMMoveWidget(fPtr->fileField, 60, 278);
+	WMResizeWidget(fPtr->fileField, PWIDTH - 60 - 10, 24);
+	WMAddNotificationObserver(textEditedObserver, fPtr, WMTextDidEndEditingNotification, fPtr->fileField);
+	WMAddNotificationObserver(textChangedObserver, fPtr, WMTextDidChangeNotification, fPtr->fileField);
+
+	fPtr->okButton = WMCreateCommandButton(fPtr->win);
+	WMMoveWidget(fPtr->okButton, 245, 325);
+	WMResizeWidget(fPtr->okButton, 75, 28);
+	WMSetButtonText(fPtr->okButton, _("OK"));
+	WMSetButtonImage(fPtr->okButton, scrPtr->buttonArrow);
+	WMSetButtonAltImage(fPtr->okButton, scrPtr->pushedButtonArrow);
+	WMSetButtonImagePosition(fPtr->okButton, WIPRight);
+	WMSetButtonAction(fPtr->okButton, buttonClick, fPtr);
+
+	fPtr->cancelButton = WMCreateCommandButton(fPtr->win);
+	WMMoveWidget(fPtr->cancelButton, 165, 325);
+	WMResizeWidget(fPtr->cancelButton, 75, 28);
+	WMSetButtonText(fPtr->cancelButton, _("Cancel"));
+	WMSetButtonAction(fPtr->cancelButton, buttonClick, fPtr);
+
+	fPtr->trashcanButton = WMCreateCommandButton(fPtr->win);
+	WMMoveWidget(fPtr->trashcanButton, 7, 325);
+	WMResizeWidget(fPtr->trashcanButton, 28, 28);
+	WMSetButtonImagePosition(fPtr->trashcanButton, WIPImageOnly);
+	WMSetButtonImage(fPtr->trashcanButton, scrPtr->trashcanIcon);
+	WMSetButtonAltImage(fPtr->trashcanButton, scrPtr->altTrashcanIcon);
+	WMSetButtonAction(fPtr->trashcanButton, deleteFile, fPtr);
+
+	fPtr->createDirButton = WMCreateCommandButton(fPtr->win);
+	WMMoveWidget(fPtr->createDirButton, 37, 325);
+	WMResizeWidget(fPtr->createDirButton, 28, 28);
+	WMSetButtonImagePosition(fPtr->createDirButton, WIPImageOnly);
+	WMSetButtonImage(fPtr->createDirButton, scrPtr->createDirIcon);
+	WMSetButtonAltImage(fPtr->createDirButton, scrPtr->altCreateDirIcon);
+	WMSetButtonAction(fPtr->createDirButton, createDir, fPtr);
+
+	fPtr->homeButton = WMCreateCommandButton(fPtr->win);
+	WMMoveWidget(fPtr->homeButton, 67, 325);
+	WMResizeWidget(fPtr->homeButton, 28, 28);
+	WMSetButtonImagePosition(fPtr->homeButton, WIPImageOnly);
+	WMSetButtonImage(fPtr->homeButton, scrPtr->homeIcon);
+	WMSetButtonAltImage(fPtr->homeButton, scrPtr->altHomeIcon);
+	WMSetButtonAction(fPtr->homeButton, goHome, fPtr);
+
+	fPtr->disketteButton = WMCreateCommandButton(fPtr->win);
+	WMMoveWidget(fPtr->disketteButton, 97, 325);
+	WMResizeWidget(fPtr->disketteButton, 28, 28);
+	WMSetButtonImagePosition(fPtr->disketteButton, WIPImageOnly);
+	WMSetButtonImage(fPtr->disketteButton, scrPtr->disketteIcon);
+	WMSetButtonAltImage(fPtr->disketteButton, scrPtr->altDisketteIcon);
+	WMSetButtonAction(fPtr->disketteButton, goFloppy, fPtr);
+
+	fPtr->unmountButton = WMCreateCommandButton(fPtr->win);
+	WMMoveWidget(fPtr->unmountButton, 127, 325);
+	WMResizeWidget(fPtr->unmountButton, 28, 28);
+	WMSetButtonImagePosition(fPtr->unmountButton, WIPImageOnly);
+	WMSetButtonImage(fPtr->unmountButton, scrPtr->unmountIcon);
+	WMSetButtonAltImage(fPtr->unmountButton, scrPtr->altUnmountIcon);
+	WMSetButtonAction(fPtr->unmountButton, goUnmount, fPtr);
+	WMSetButtonEnabled(fPtr->unmountButton, False);
+
+	WMRealizeWidget(fPtr->win);
+	WMMapSubwidgets(fPtr->win);
+
+	WMSetFocusToWidget(fPtr->fileField);
+	WMSetTextFieldCursorPosition(fPtr->fileField, 0);
+
+	WMLoadBrowserColumnZero(fPtr->browser);
+
+	WMSetWindowInitialPosition(fPtr->win,
+				   (scrPtr->rootView->size.width - WMWidgetWidth(fPtr->win)) / 2,
+				   (scrPtr->rootView->size.height - WMWidgetHeight(fPtr->win)) / 2);
+
+	fPtr->flags.canChooseFiles = 1;
+	fPtr->flags.canChooseDirectories = 1;
+	fPtr->flags.autoCompletion = 1;
+
+	return fPtr;
+}
+
+WMOpenPanel *WMGetOpenPanel(WMScreen * scrPtr)
+{
+	WMFilePanel *panel;
+
+	if (scrPtr->sharedOpenPanel)
+		return scrPtr->sharedOpenPanel;
+
+	panel = makeFilePanel(scrPtr, "openFilePanel", _("Open"));
+	panel->flags.fileMustExist = 1;
+	panel->flags.panelType = WP_OPEN;
+
+	scrPtr->sharedOpenPanel = panel;
+
+	return panel;
+}
+
+WMSavePanel *WMGetSavePanel(WMScreen * scrPtr)
+{
+	WMFilePanel *panel;
+
+	if (scrPtr->sharedSavePanel)
+		return scrPtr->sharedSavePanel;
+
+	panel = makeFilePanel(scrPtr, "saveFilePanel", _("Save"));
+	panel->flags.fileMustExist = 0;
+	panel->flags.panelType = WP_SAVE;
+
+	scrPtr->sharedSavePanel = panel;
+
+	return panel;
+}
+
+void WMFreeFilePanel(WMFilePanel * panel)
+{
+	if (panel == WMWidgetScreen(panel->win)->sharedSavePanel) {
+		WMWidgetScreen(panel->win)->sharedSavePanel = NULL;
+	}
+	if (panel == WMWidgetScreen(panel->win)->sharedOpenPanel) {
+		WMWidgetScreen(panel->win)->sharedOpenPanel = NULL;
+	}
+	WMRemoveNotificationObserver(panel);
+	WMUnmapWidget(panel->win);
+	WMDestroyWidget(panel->win);
+	wfree(panel);
+}
+
+int
+WMRunModalFilePanelForDirectory(WMFilePanel * panel, WMWindow * owner, const char *path, const char *name, char **fileTypes)
+{
+	WMScreen *scr = WMWidgetScreen(panel->win);
+
+	if (name && !owner) {
+		WMSetWindowTitle(panel->win, name);
+	}
+
+	WMChangePanelOwner(panel->win, owner);
+
+	WMSetFilePanelDirectory(panel, path);
+
+	switch (panel->flags.panelType) {
+	case WP_OPEN:
+		if (fileTypes)
+			panel->flags.filtered = 1;
+		panel->fileTypes = fileTypes;
+		if (name == NULL)
+			name = _("Open");
+		break;
+	case WP_SAVE:
+		panel->fileTypes = NULL;
+		panel->flags.filtered = 0;
+		if (name == NULL)
+			name = _("Save");
+		break;
+	default:
+		break;
+	}
+
+	WMSetLabelText(panel->titleLabel, name);
+
+	WMMapWidget(panel->win);
+
+	WMRunModalLoop(scr, W_VIEW(panel->win));
+
+	/* Must withdraw window because the next time we map
+	 * it, it might have a different transient owner.
+	 */
+	WMCloseWindow(panel->win);
+
+	return (panel->flags.canceled ? False : True);
+}
+
+void WMSetFilePanelDirectory(WMFilePanel * panel, const char *path)
+{
+	WMList *list;
+	WMListItem *item;
+	int col;
+	const char *rest;
+
+	rest = WMSetBrowserPath(panel->browser, path);
+	if (strcmp(path, "/") == 0)
+		rest = NULL;
+
+	col = WMGetBrowserSelectedColumn(panel->browser);
+	list = WMGetBrowserListInColumn(panel->browser, col);
+	if (list && (item = WMGetListSelectedItem(list))) {
+		if (item->isBranch) {
+			WMSetTextFieldText(panel->fileField, rest);
+		} else {
+			WMSetTextFieldText(panel->fileField, item->text);
+		}
+	} else {
+		WMSetTextFieldText(panel->fileField, rest);
+	}
+}
+
+void WMSetFilePanelCanChooseDirectories(WMFilePanel * panel, Bool flag)
+{
+	panel->flags.canChooseDirectories = ((flag == 0) ? 0 : 1);
+}
+
+void WMSetFilePanelCanChooseFiles(WMFilePanel * panel, Bool flag)
+{
+	panel->flags.canChooseFiles = ((flag == 0) ? 0 : 1);
+}
+
+void WMSetFilePanelAutoCompletion(WMFilePanel * panel, Bool flag)
+{
+	panel->flags.autoCompletion = ((flag == 0) ? 0 : 1);
+}
+
+char *WMGetFilePanelFileName(WMFilePanel * panel)
+{
+	return getCurrentFileName(panel);
+}
+
+void WMSetFilePanelAccessoryView(WMFilePanel * panel, WMView * view)
+{
+	WMView *v;
+
+	panel->accessoryView = view;
+
+	v = WMWidgetView(panel->win);
+
+	W_ReparentView(view, v, 0, 0);
+
+	W_MoveView(view, (v->size.width - v->size.width) / 2, 300);
+}
+
+WMView *WMGetFilePanelAccessoryView(WMFilePanel * panel)
+{
+	return panel->accessoryView;
+}
+
+static char *get_name_from_path(const char *path)
+{
+	int size;
+
+	assert(path != NULL);
+
+	size = strlen(path);
+
+	/* remove trailing / */
+	while (size > 0 && path[size - 1] == '/')
+		size--;
+	/* directory was root */
+	if (size == 0)
+		return wstrdup("/");
+
+	while (size > 0 && path[size - 1] != '/')
+		size--;
+
+	return wstrdup(&(path[size]));
+}
+
+#define CAST(item) (*((WMListItem**)item))
+static int comparer(const void *a, const void *b)
+{
+	if (CAST(a)->isBranch == CAST(b)->isBranch)
+		return (strcmp(CAST(a)->text, CAST(b)->text));
+	if (CAST(a)->isBranch)
+		return (-1);
+	return (1);
+}
+
+#undef CAST
+
+static void listDirectoryOnColumn(WMFilePanel * panel, int column, const char *path)
+{
+	WMBrowser *bPtr = panel->browser;
+	struct dirent *dentry;
+	DIR *dir;
+	struct stat stat_buf;
+	char pbuf[PATH_MAX + 16];
+	char *name;
+
+	assert(column >= 0);
+	assert(path != NULL);
+
+	/* put directory name in the title */
+	name = get_name_from_path(path);
+	WMSetBrowserColumnTitle(bPtr, column, name);
+	wfree(name);
+
+	dir = opendir(path);
+
+	if (!dir) {
+#ifdef VERBOSE
+		printf(_("WINGs: could not open directory %s\n"), path);
+#endif
+		return;
+	}
+
+	/* list contents in the column */
+	while ((dentry = readdir(dir))) {
+		if (strcmp(dentry->d_name, ".") == 0 || strcmp(dentry->d_name, "..") == 0)
+			continue;
+
+		if (wstrlcpy(pbuf, path, sizeof(pbuf)) >= sizeof(pbuf))
+			goto out;
+		if (strcmp(path, "/") != 0 &&
+		    wstrlcat(pbuf, "/", sizeof(pbuf)) >= sizeof(pbuf))
+			goto out;
+		if (wstrlcat(pbuf, dentry->d_name, sizeof(pbuf)) >= sizeof(pbuf))
+			goto out;
+
+		if (stat(pbuf, &stat_buf) != 0) {
+#ifdef VERBOSE
+			printf(_("WINGs: could not stat %s\n"), pbuf);
+#endif
+			continue;
+		} else {
+			int isDirectory;
+
+			isDirectory = S_ISDIR(stat_buf.st_mode);
+			WMInsertBrowserItem(bPtr, column, -1, dentry->d_name, isDirectory);
+		}
+	}
+	WMSortBrowserColumnWithComparer(bPtr, column, comparer);
+
+out:
+	closedir(dir);
+}
+
+static void fillColumn(WMBrowserDelegate * self, WMBrowser * bPtr, int column, WMList * list)
+{
+	char *path;
+	WMFilePanel *panel;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) self;
+	(void) list;
+
+	if (column > 0) {
+		path = WMGetBrowserPathToColumn(bPtr, column - 1);
+	} else {
+		path = wstrdup("/");
+	}
+
+	panel = WMGetHangedData(bPtr);
+	listDirectoryOnColumn(panel, column, path);
+	wfree(path);
+}
+
+static void browserDClick(WMWidget *widget, void *p_panel)
+{
+	WMFilePanel *panel = p_panel;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) widget;
+
+	WMPerformButtonClick(panel->okButton);
+}
+
+static void browserClick(WMWidget *widget, void *p_panel)
+{
+	WMBrowser *bPtr = (WMBrowser *) widget;
+	WMFilePanel *panel = p_panel;
+	int col = WMGetBrowserSelectedColumn(bPtr);
+	WMListItem *item = WMGetBrowserSelectedItemInColumn(bPtr, col);
+
+	if (!item || item->isBranch)
+		WMSetTextFieldText(panel->fileField, NULL);
+	else {
+		WMSetTextFieldText(panel->fileField, item->text);
+	}
+}
+
+static void showError(WMScreen * scr, WMWindow * owner, const char *s, const char *file)
+{
+	char *errStr;
+
+	if (file) {
+		errStr = wmalloc(strlen(file) + strlen(s) + 1);
+		sprintf(errStr, s, file);
+	} else {
+		errStr = wstrdup(s);
+	}
+	WMRunAlertPanel(scr, owner, _("Error"), errStr, _("OK"), NULL, NULL);
+	wfree(errStr);
+}
+
+static void createDir(WMWidget *widget, void *p_panel)
+{
+	WMFilePanel *panel = p_panel;
+	char *dirName, *directory, *file;
+	size_t slen;
+	WMScreen *scr = WMWidgetScreen(panel->win);
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) widget;
+
+	dirName = WMRunInputPanel(scr, panel->win, _("Create Directory"),
+				  _("Enter directory name"), "", _("OK"), _("Cancel"));
+	if (!dirName)
+		return;
+
+	/* if `dirName' is an absolute path, don't mind `directory'.
+	 * normalize as needed (possibly not needed at all?) */
+	normalizePath(dirName);
+	if (*dirName != '/') {
+		directory = getCurrentFileName(panel);
+		normalizePath(directory);
+	} else {
+		directory = NULL;
+	}
+
+	slen = strlen(dirName) + (directory ? strlen(directory) + 1 /* "/" */  : 0) + 1 /* NULL */;
+	file = wmalloc(slen);
+
+	if (directory &&
+		(wstrlcat(file, directory, slen) >= slen ||
+		 wstrlcat(file, "/", slen) >= slen))
+			goto out;
+
+	if (wstrlcat(file, dirName, slen) >= slen)
+		goto out;
+
+	if (mkdir(file, 00777) != 0) {
+#define __msgbufsize__ 512
+		char *buffer = wmalloc(__msgbufsize__);
+		snprintf(buffer, __msgbufsize__, _("Can not create %s: %s"), file, strerror(errno));
+		showError(scr, panel->win, buffer, NULL);
+		wfree(buffer);
+#undef __msgbufsize__
+	} else {
+		WMSetFilePanelDirectory(panel, file);
+	}
+
+out:
+	if (dirName)
+		wfree(dirName);
+	if (directory)
+		wfree(directory);
+	if (file)
+		wfree(file);
+}
+
+/*
+ *----------------------------------------------------------------------
+ * normalizePath--
+ *	Remove multiple consecutive and any trailing slashes from
+ *	a path.
+ *----------------------------------------------------------------------
+ */
+static void normalizePath(char *s)
+{
+	int i, j, found;
+
+	found = 0;
+	for (i = 0; s[i]; (void)(!found && i++)) {
+		found = 0;
+		if (s[i] == '/' && s[i+1] == '/') {
+			int nslash = 1;
+			found = 1;
+			i++;
+			while (s[i+nslash] == '/')
+				nslash++;
+			for (j = 0; s[i+j+nslash]; j++)
+				s[i+j] = s[i+j+nslash];
+			s[i+j] = '\0';
+		}
+	}
+	if (i > 1 && s[--i] == '/')
+		s[i] = '\0';
+}
+
+
+static void deleteFile(WMWidget *widget, void *p_panel)
+{
+	WMFilePanel *panel = p_panel;
+	char *file;
+	char buffer[512];
+	struct stat filestat;
+	WMScreen *scr = WMWidgetScreen(panel->win);
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) widget;
+
+	file = getCurrentFileName(panel);
+	if (file == NULL)
+		return;
+
+	normalizePath(file);
+
+	if (stat(file, &filestat) == -1) {
+		snprintf(buffer, sizeof(buffer),
+		         _("Can not find %s: %s"),
+		         file, strerror(errno));
+		showError(scr, panel->win, buffer, NULL);
+		goto out;
+	}
+
+	snprintf(buffer, sizeof(buffer), _("Delete %s %s?"),
+		S_ISDIR(filestat.st_mode) ? _("directory") : _("file"), file);
+
+	if (!WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
+			     _("Warning"), buffer, _("OK"), _("Cancel"), NULL)) {
+
+		if (remove(file) == -1) {
+			snprintf(buffer, sizeof(buffer),
+			         _("Removing %s failed: %s"),
+			         file, strerror(errno));
+			showError(scr, panel->win, buffer, NULL);
+		} else {
+			char *s = strrchr(file, '/');
+			if (s)
+				s[0] = 0;
+			WMSetFilePanelDirectory(panel, file);
+		}
+
+	}
+out:
+	wfree(file);
+}
+
+static void goUnmount(WMWidget *widget, void *p_panel)
+{
+	/* Not implemented yet */
+	(void) widget;
+	(void) p_panel;
+}
+
+static void goFloppy(WMWidget *widget, void *p_panel)
+{
+	WMFilePanel *panel = p_panel;
+	struct stat filestat;
+	WMScreen *scr = WMWidgetScreen(panel->win);
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) widget;
+
+	if (stat(WINGsConfiguration.floppyPath, &filestat)) {
+		showError(scr, panel->win, _("An error occurred browsing '%s'."), WINGsConfiguration.floppyPath);
+		return;
+	} else if (!S_ISDIR(filestat.st_mode)) {
+		showError(scr, panel->win, _("'%s' is not a directory."), WINGsConfiguration.floppyPath);
+		return;
+	}
+
+	WMSetFilePanelDirectory(panel, WINGsConfiguration.floppyPath);
+}
+
+static void goHome(WMWidget *widget, void *p_panel)
+{
+	WMFilePanel *panel = p_panel;
+	const char *home;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) widget;
+
+	/* home is statically allocated. Don't free it! */
+	home = wgethomedir();
+	if (!home)
+		return;
+
+	WMSetFilePanelDirectory(panel, home);
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	W_FilePanel *pPtr = (W_FilePanel *) data;
+	W_View *view = WMWidgetView(pPtr->win);
+
+	if (event->type == ConfigureNotify) {
+		if (event->xconfigure.width != view->size.width || event->xconfigure.height != view->size.height) {
+			unsigned int newWidth = event->xconfigure.width;
+			unsigned int newHeight = event->xconfigure.height;
+			int newColumnCount;
+
+			W_ResizeView(view, newWidth, newHeight);
+			WMResizeWidget(pPtr->line, newWidth, 2);
+			WMResizeWidget(pPtr->browser, newWidth - 14, newHeight - (PHEIGHT - 200));
+			WMResizeWidget(pPtr->fileField, newWidth - 60 - 10, 24);
+			WMMoveWidget(pPtr->nameLabel, 7, newHeight - (PHEIGHT - 282));
+			WMMoveWidget(pPtr->fileField, 60, newHeight - (PHEIGHT - 278));
+			WMMoveWidget(pPtr->okButton, newWidth - (PWIDTH - 245), newHeight - (PHEIGHT - 325));
+			WMMoveWidget(pPtr->cancelButton, newWidth - (PWIDTH - 165), newHeight - (PHEIGHT - 325));
+
+			WMMoveWidget(pPtr->trashcanButton, 7, newHeight - (PHEIGHT - 325));
+			WMMoveWidget(pPtr->createDirButton, 37, newHeight - (PHEIGHT - 325));
+			WMMoveWidget(pPtr->homeButton, 67, newHeight - (PHEIGHT - 325));
+			WMMoveWidget(pPtr->disketteButton, 97, newHeight - (PHEIGHT - 325));
+			WMMoveWidget(pPtr->unmountButton, 127, newHeight - (PHEIGHT - 325));
+
+			newColumnCount = (newWidth - 14) / 140;
+			WMSetBrowserMaxVisibleColumns(pPtr->browser, newColumnCount);
+		}
+	}
+}
+
+static char *getCurrentFileName(WMFilePanel * panel)
+{
+	char *path;
+	char *file;
+	char *ret;
+	size_t slen;
+
+	path = WMGetBrowserPath(panel->browser);
+
+	if (!path)
+		return NULL;
+
+	if (path[strlen(path) -1] != '/')
+		return path;
+
+	file = WMGetTextFieldText(panel->fileField);
+	slen = strlen(path) + strlen(file) + 1;
+	ret = wmalloc(slen);
+
+	if (file[0] != '/')
+		strcpy(ret, path);
+
+	strcat(ret, file);
+
+	wfree(file);
+	wfree(path);
+	return ret;
+}
+
+
+static Bool validOpenFile(WMFilePanel * panel)
+{
+	WMListItem *item;
+	int col, haveFile = 0;
+	char *file = WMGetTextFieldText(panel->fileField);
+
+	if (file[0] != '\0')
+		haveFile = 1;
+	wfree(file);
+
+	col = WMGetBrowserSelectedColumn(panel->browser);
+	item = WMGetBrowserSelectedItemInColumn(panel->browser, col);
+	if (item) {
+		if (item->isBranch && !panel->flags.canChooseDirectories && !haveFile)
+			return False;
+		else if (!item->isBranch && !panel->flags.canChooseFiles)
+			return False;
+		else
+			return True;
+	} else {
+		/* we compute for / here */
+		if (!panel->flags.canChooseDirectories && !haveFile)
+			return False;
+		else
+			return True;
+	}
+	return True;
+}
+
+static void buttonClick(WMWidget *widget, void *p_panel)
+{
+	WMButton *bPtr = (WMButton *) widget;
+	WMFilePanel *panel = p_panel;
+	WMRange range;
+
+	if (bPtr == panel->okButton) {
+		if (!validOpenFile(panel))
+			return;
+		if (panel->flags.fileMustExist) {
+			char *file;
+
+			file = getCurrentFileName(panel);
+			if (access(file, F_OK) != 0) {
+				WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
+						_("Error"), _("File does not exist."), _("OK"), NULL, NULL);
+				wfree(file);
+				return;
+			}
+			wfree(file);
+		}
+		panel->flags.canceled = 0;
+	} else
+		panel->flags.canceled = 1;
+
+	range.count = range.position = 0;
+	WMSelectTextFieldRange(panel->fileField, range);
+	WMBreakModalLoop(WMWidgetScreen(bPtr));
+}

bazel/WINGs/wfont.c

@@ -0,0 +1,429 @@
+
+#include <stdlib.h>
+
+#include "wconfig.h"
+
+#include "WINGs/WINGsP.h"
+
+#include "wrlib/wraster.h"
+
+#include <assert.h>
+#include <X11/Xlocale.h>
+
+#include <X11/Xft/Xft.h>
+#include <fontconfig/fontconfig.h>
+
+// TODO: Pango was originally optional.
+/* #ifdef USE_PANGO */
+#include "pango/pango.h"
+#include "pango/pangofc-fontmap.h"
+#include "pango/pangoxft.h"
+/* #endif */
+
+#define DEFAULT_FONT "sans serif:pixelsize=12"
+
+#define DEFAULT_SIZE WINGsConfiguration.defaultFontSize
+
+static FcPattern *xlfdToFcPattern(const char *xlfd)
+{
+	FcPattern *pattern;
+	char *fname, *ptr;
+
+	/* Just skip old font names that contain %d in them.
+	 * We don't support that anymore. */
+	if (strchr(xlfd, '%') != NULL)
+		return FcNameParse((FcChar8 *) DEFAULT_FONT);
+
+	fname = wstrdup(xlfd);
+	if ((ptr = strchr(fname, ','))) {
+		*ptr = 0;
+	}
+	pattern = XftXlfdParse(fname, False, False);
+	wfree(fname);
+
+	if (!pattern) {
+		wwarning(_("invalid font: %s. Trying '%s'"), xlfd, DEFAULT_FONT);
+		pattern = FcNameParse((FcChar8 *) DEFAULT_FONT);
+	}
+
+	return pattern;
+}
+
+static char *xlfdToFcName(const char *xlfd)
+{
+	FcPattern *pattern;
+	char *fname;
+
+	pattern = xlfdToFcPattern(xlfd);
+	fname = (char *)FcNameUnparse(pattern);
+	FcPatternDestroy(pattern);
+
+	return fname;
+}
+
+static Bool hasProperty(FcPattern * pattern, const char *property)
+{
+	FcValue val;
+
+	if (FcPatternGet(pattern, property, 0, &val) == FcResultMatch) {
+		return True;
+	}
+
+	return False;
+}
+
+static Bool hasPropertyWithStringValue(FcPattern * pattern, const char *object, const char *value)
+{
+	FcChar8 *str;
+	int id;
+
+	if (!value || value[0] == 0)
+		return True;
+
+	id = 0;
+	while (FcPatternGetString(pattern, object, id, &str) == FcResultMatch) {
+		if (strcasecmp(value, (char *)str) == 0) {
+			return True;
+		}
+		id++;
+	}
+
+	return False;
+}
+
+static char *makeFontOfSize(const char *font, int size, const char *fallback)
+{
+	FcPattern *pattern;
+	char *result;
+
+	if (font[0] == '-') {
+		pattern = xlfdToFcPattern(font);
+	} else {
+		pattern = FcNameParse((const FcChar8 *) font);
+	}
+
+	/*FcPatternPrint(pattern); */
+
+	if (size > 0) {
+		FcPatternDel(pattern, FC_PIXEL_SIZE);
+		FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)size);
+	} else if (size == 0 && !hasProperty(pattern, "size") && !hasProperty(pattern, FC_PIXEL_SIZE)) {
+		FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)DEFAULT_SIZE);
+	}
+
+	if (fallback && !hasPropertyWithStringValue(pattern, FC_FAMILY, fallback)) {
+		FcPatternAddString(pattern, FC_FAMILY, (const FcChar8 *) fallback);
+	}
+
+	/*FcPatternPrint(pattern); */
+
+	result = (char *)FcNameUnparse(pattern);
+	FcPatternDestroy(pattern);
+
+	return result;
+}
+
+WMFont *WMCreateFont(WMScreen * scrPtr, const char *fontName)
+{
+	Display *display = scrPtr->display;
+	WMFont *font;
+	char *fname;
+#ifdef USE_PANGO
+	PangoFontMap *fontmap;
+	PangoContext *context;
+	PangoLayout *layout;
+	FcPattern *pattern;
+	PangoFontDescription *description;
+	double size;
+#endif
+
+	if (fontName[0] == '-') {
+		fname = xlfdToFcName(fontName);
+	} else {
+		fname = wstrdup(fontName);
+	}
+
+	if (!WINGsConfiguration.antialiasedText && !strstr(fname, ":antialias=")) {
+		fname = wstrappend(fname, ":antialias=false");
+	}
+
+	font = WMHashGet(scrPtr->fontCache, fname);
+	if (font) {
+		WMRetainFont(font);
+		wfree(fname);
+		return font;
+	}
+
+	font = wmalloc(sizeof(WMFont));
+
+	font->screen = scrPtr;
+
+	font->font = XftFontOpenName(display, scrPtr->screen, fname);
+	if (!font->font) {
+		wfree(font);
+		wfree(fname);
+		return NULL;
+	}
+
+	font->height = font->font->ascent + font->font->descent;
+	font->y = font->font->ascent;
+
+	font->refCount = 1;
+
+	font->name = fname;
+
+#ifdef USE_PANGO
+	fontmap = pango_xft_get_font_map(scrPtr->display, scrPtr->screen);
+	context = pango_font_map_create_context(fontmap);
+	layout = pango_layout_new(context);
+
+	pattern = FcNameParse((FcChar8 *) font->name);
+	description = pango_fc_font_description_from_pattern(pattern, FALSE);
+
+	/* Pango examines FC_SIZE but not FC_PIXEL_SIZE of the patten, but
+	 * font-name has only "pixelsize", so set the size manually here.
+	 */
+	if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &size) == FcResultMatch)
+		pango_font_description_set_absolute_size(description, size * PANGO_SCALE);
+
+	pango_layout_set_font_description(layout, description);
+
+	font->layout = layout;
+#endif
+
+	assert(WMHashInsert(scrPtr->fontCache, font->name, font) == NULL);
+
+	return font;
+}
+
+WMFont *WMRetainFont(WMFont * font)
+{
+	wassertrv(font != NULL, NULL);
+
+	font->refCount++;
+
+	return font;
+}
+
+void WMReleaseFont(WMFont * font)
+{
+	wassertr(font != NULL);
+
+	font->refCount--;
+	if (font->refCount < 1) {
+		XftFontClose(font->screen->display, font->font);
+		if (font->name) {
+			WMHashRemove(font->screen->fontCache, font->name);
+			wfree(font->name);
+		}
+		wfree(font);
+	}
+}
+
+Bool WMIsAntialiasingEnabled(WMScreen * scrPtr)
+{
+	return scrPtr->antialiasedText;
+}
+
+unsigned int WMFontHeight(WMFont * font)
+{
+	wassertrv(font != NULL, 0);
+
+	return font->height;
+}
+
+char *WMGetFontName(WMFont * font)
+{
+	wassertrv(font != NULL, NULL);
+
+	return font->name;
+}
+
+void WMGetScaleBaseFromSystemFont(WMScreen *scrPtr, int *alphabetWidth, int *fontHeight)
+{
+	WMFont *font;
+
+	font = WMDefaultSystemFont(scrPtr);
+	*alphabetWidth = WMWidthOfString(font, "abcdefghijklmnopqrstuvwxyz", 26);
+	*fontHeight = WMFontHeight(font);
+	WMReleaseFont(font);
+}
+
+WMFont *WMDefaultSystemFont(WMScreen * scrPtr)
+{
+	return WMRetainFont(scrPtr->normalFont);
+}
+
+WMFont *WMDefaultBoldSystemFont(WMScreen * scrPtr)
+{
+	return WMRetainFont(scrPtr->boldFont);
+}
+
+WMFont *WMSystemFontOfSize(WMScreen * scrPtr, int size)
+{
+	WMFont *font;
+	char *fontSpec;
+
+	fontSpec = makeFontOfSize(WINGsConfiguration.systemFont, size, NULL);
+
+	font = WMCreateFont(scrPtr, fontSpec);
+
+	if (!font) {
+		wwarning(_("could not load font: %s."), fontSpec);
+	}
+
+	wfree(fontSpec);
+
+	return font;
+}
+
+WMFont *WMBoldSystemFontOfSize(WMScreen * scrPtr, int size)
+{
+	WMFont *font;
+	char *fontSpec;
+
+	fontSpec = makeFontOfSize(WINGsConfiguration.boldSystemFont, size, NULL);
+
+	font = WMCreateFont(scrPtr, fontSpec);
+
+	if (!font) {
+		wwarning(_("could not load font: %s."), fontSpec);
+	}
+
+	wfree(fontSpec);
+
+	return font;
+}
+
+int WMWidthOfString(WMFont * font, const char *text, int length)
+{
+#ifdef USE_PANGO
+	const char *previous_text;
+	int width;
+#else
+	XGlyphInfo extents;
+#endif
+
+	wassertrv(font != NULL && text != NULL, 0);
+#ifdef USE_PANGO
+	previous_text = pango_layout_get_text(font->layout);
+	if ((previous_text == NULL) || (strncmp(text, previous_text, length) != 0) || previous_text[length] != '\0')
+		pango_layout_set_text(font->layout, text, length);
+	pango_layout_get_pixel_size(font->layout, &width, NULL);
+
+	return width;
+#else
+	XftTextExtentsUtf8(font->screen->display, font->font, (XftChar8 *) text, length, &extents);
+
+	return extents.xOff;	/* don't ask :P */
+#endif
+}
+
+void WMDrawString(WMScreen * scr, Drawable d, WMColor * color, WMFont * font, int x, int y, const char *text, int length)
+{
+	XftColor xftcolor;
+#ifdef USE_PANGO
+	const char *previous_text;
+#endif
+
+	wassertr(font != NULL);
+
+	xftcolor.color.red = color->color.red;
+	xftcolor.color.green = color->color.green;
+	xftcolor.color.blue = color->color.blue;
+	xftcolor.color.alpha = color->alpha;;
+	xftcolor.pixel = W_PIXEL(color);
+
+	XftDrawChange(scr->xftdraw, d);
+
+#ifdef USE_PANGO
+	previous_text = pango_layout_get_text(font->layout);
+	if ((previous_text == NULL) || (strcmp(text, previous_text) != 0))
+		pango_layout_set_text(font->layout, text, length);
+	pango_xft_render_layout(scr->xftdraw, &xftcolor, font->layout, x * PANGO_SCALE, y * PANGO_SCALE);
+#else
+	XftDrawStringUtf8(scr->xftdraw, &xftcolor, font->font, x, y + font->y, (XftChar8 *) text, length);
+#endif
+}
+
+void
+WMDrawImageString(WMScreen * scr, Drawable d, WMColor * color, WMColor * background,
+		  WMFont * font, int x, int y, const char *text, int length)
+{
+	XftColor textColor;
+	XftColor bgColor;
+#ifdef USE_PANGO
+	const char *previous_text;
+#endif
+
+	wassertr(font != NULL);
+
+	textColor.color.red = color->color.red;
+	textColor.color.green = color->color.green;
+	textColor.color.blue = color->color.blue;
+	textColor.color.alpha = color->alpha;;
+	textColor.pixel = W_PIXEL(color);
+
+	bgColor.color.red = background->color.red;
+	bgColor.color.green = background->color.green;
+	bgColor.color.blue = background->color.blue;
+	bgColor.color.alpha = background->alpha;;
+	bgColor.pixel = W_PIXEL(background);
+
+	XftDrawChange(scr->xftdraw, d);
+
+	XftDrawRect(scr->xftdraw, &bgColor, x, y, WMWidthOfString(font, text, length), font->height);
+
+#ifdef USE_PANGO
+	previous_text = pango_layout_get_text(font->layout);
+	if ((previous_text == NULL) || (strcmp(text, previous_text) != 0))
+		pango_layout_set_text(font->layout, text, length);
+	pango_xft_render_layout(scr->xftdraw, &textColor, font->layout, x * PANGO_SCALE, y * PANGO_SCALE);
+#else
+	XftDrawStringUtf8(scr->xftdraw, &textColor, font->font, x, y + font->y, (XftChar8 *) text, length);
+#endif
+}
+
+WMFont *WMCopyFontWithStyle(WMScreen * scrPtr, WMFont * font, WMFontStyle style)
+{
+	FcPattern *pattern;
+	WMFont *copy;
+	char *name;
+
+	if (!font)
+		return NULL;
+
+	/* It's enough to add italic to slant, even if the font has no italic
+	 * variant, but only oblique. This is because fontconfig will actually
+	 * return the closest match font to what we requested which is the
+	 * oblique font. Same goes for using bold for weight.
+	 */
+	pattern = FcNameParse((FcChar8 *) WMGetFontName(font));
+	switch (style) {
+	case WFSNormal:
+		FcPatternDel(pattern, FC_WEIGHT);
+		FcPatternDel(pattern, FC_SLANT);
+		break;
+	case WFSBold:
+		FcPatternDel(pattern, FC_WEIGHT);
+		FcPatternAddString(pattern, FC_WEIGHT, (FcChar8 *) "bold");
+		break;
+	case WFSItalic:
+		FcPatternDel(pattern, FC_SLANT);
+		FcPatternAddString(pattern, FC_SLANT, (FcChar8 *) "italic");
+		break;
+	case WFSBoldItalic:
+		FcPatternDel(pattern, FC_WEIGHT);
+		FcPatternDel(pattern, FC_SLANT);
+		FcPatternAddString(pattern, FC_WEIGHT, (FcChar8 *) "bold");
+		FcPatternAddString(pattern, FC_SLANT, (FcChar8 *) "italic");
+		break;
+	}
+
+	name = (char *)FcNameUnparse(pattern);
+	copy = WMCreateFont(scrPtr, name);
+	FcPatternDestroy(pattern);
+	wfree(name);
+
+	return copy;
+}

bazel/WINGs/wfontpanel.c

@@ -0,0 +1,825 @@
+
+#include "WINGs/WINGsP.h"
+#include "WINGs/WUtil.h"
+#include "WINGs/wconfig.h"
+
+#include <ctype.h>
+#include <string.h>
+#include <strings.h>
+#include <stdint.h>
+
+#include <X11/Xft/Xft.h>
+#include <fontconfig/fontconfig.h>
+
+/* XXX TODO */
+char *WMFontPanelFontChangedNotification = "WMFontPanelFontChangedNotification";
+
+typedef struct W_FontPanel {
+	WMWindow *win;
+
+	WMFrame *upperF;
+	WMTextField *sampleT;
+
+	WMSplitView *split;
+
+	WMFrame *lowerF;
+	WMLabel *famL;
+	WMList *famLs;
+	WMLabel *typL;
+	WMList *typLs;
+	WMLabel *sizL;
+	WMTextField *sizT;
+	WMList *sizLs;
+
+	WMAction2 *action;
+	void *data;
+
+	WMButton *revertB;
+	WMButton *setB;
+
+	WMPropList *fdb;
+} FontPanel;
+
+#define MIN_UPPER_HEIGHT	20
+#define MIN_LOWER_HEIGHT	140
+
+#define BUTTON_SPACE_HEIGHT 40
+
+#define MIN_WIDTH	250
+#define MIN_HEIGHT 	(MIN_UPPER_HEIGHT+MIN_LOWER_HEIGHT+BUTTON_SPACE_HEIGHT)
+
+#define DEF_UPPER_HEIGHT 60
+#define DEF_LOWER_HEIGHT 310
+
+#define DEF_WIDTH	320
+#define DEF_HEIGHT	(DEF_UPPER_HEIGHT+DEF_LOWER_HEIGHT)
+
+static const int scalableFontSizes[] = {
+	8,
+	10,
+	11,
+	12,
+	14,
+	16,
+	18,
+	20,
+	24,
+	36,
+	48,
+	64
+};
+
+static void setFontPanelFontName(FontPanel * panel, const char *family, const char *style, double size);
+
+static int isXLFD(const char *font, int *length_ret);
+
+static void arrangeLowerFrame(FontPanel * panel);
+
+static void familyClick(WMWidget *, void *);
+static void typefaceClick(WMWidget *, void *);
+static void sizeClick(WMWidget *, void *);
+
+static void listFamilies(WMScreen * scr, WMFontPanel * panel);
+
+static void splitViewConstrainCallback(WMSplitView * sPtr, int indView, int *min, int *max)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) sPtr;
+	(void) max;
+
+	if (indView == 0)
+		*min = MIN_UPPER_HEIGHT;
+	else
+		*min = MIN_LOWER_HEIGHT;
+}
+
+static void notificationObserver(void *self, WMNotification * notif)
+{
+	WMFontPanel *panel = (WMFontPanel *) self;
+	void *object = WMGetNotificationObject(notif);
+
+	if (WMGetNotificationName(notif) == WMViewSizeDidChangeNotification) {
+		if (object == WMWidgetView(panel->win)) {
+			int h = WMWidgetHeight(panel->win);
+			int w = WMWidgetWidth(panel->win);
+
+			WMResizeWidget(panel->split, w, h - BUTTON_SPACE_HEIGHT);
+
+			WMMoveWidget(panel->setB, w - 80, h - (BUTTON_SPACE_HEIGHT - 5));
+
+			WMMoveWidget(panel->revertB, w - 240, h - (BUTTON_SPACE_HEIGHT - 5));
+
+		} else if (object == WMWidgetView(panel->upperF)) {
+
+			if (WMWidgetHeight(panel->upperF) < MIN_UPPER_HEIGHT) {
+				WMResizeWidget(panel->upperF, WMWidgetWidth(panel->upperF), MIN_UPPER_HEIGHT);
+			} else {
+				WMResizeWidget(panel->sampleT, WMWidgetWidth(panel->upperF) - 20,
+					       WMWidgetHeight(panel->upperF) - 10);
+			}
+
+		} else if (object == WMWidgetView(panel->lowerF)) {
+
+			if (WMWidgetHeight(panel->lowerF) < MIN_LOWER_HEIGHT) {
+				WMResizeWidget(panel->upperF, WMWidgetWidth(panel->upperF), MIN_UPPER_HEIGHT);
+
+				WMMoveWidget(panel->lowerF, 0, WMWidgetHeight(panel->upperF)
+					     + WMGetSplitViewDividerThickness(panel->split));
+
+				WMResizeWidget(panel->lowerF, WMWidgetWidth(panel->lowerF),
+					       WMWidgetWidth(panel->split) - MIN_UPPER_HEIGHT
+					       - WMGetSplitViewDividerThickness(panel->split));
+			} else {
+				arrangeLowerFrame(panel);
+			}
+		}
+	}
+}
+
+static void closeWindow(WMWidget * w, void *data)
+{
+	FontPanel *panel = (FontPanel *) data;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) w;
+
+	WMHideFontPanel(panel);
+}
+
+static void setClickedAction(WMWidget * w, void *data)
+{
+	FontPanel *panel = (FontPanel *) data;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) w;
+
+	if (panel->action)
+		(*panel->action) (panel, panel->data);
+}
+
+static void revertClickedAction(WMWidget * w, void *data)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) w;
+	(void) data;
+
+	/*FontPanel *panel = (FontPanel*)data; */
+	/* XXX TODO */
+}
+
+WMFontPanel *WMGetFontPanel(WMScreen * scr)
+{
+	FontPanel *panel;
+	WMColor *dark, *white;
+	WMFont *font;
+	int divThickness;
+
+	if (scr->sharedFontPanel)
+		return scr->sharedFontPanel;
+
+	panel = wmalloc(sizeof(FontPanel));
+
+	panel->win = WMCreateWindow(scr, "fontPanel");
+	/*    WMSetWidgetBackgroundColor(panel->win, WMWhiteColor(scr)); */
+	WMSetWindowTitle(panel->win, _("Font Panel"));
+	WMResizeWidget(panel->win, DEF_WIDTH, DEF_HEIGHT);
+	WMSetWindowMinSize(panel->win, MIN_WIDTH, MIN_HEIGHT);
+	WMSetViewNotifySizeChanges(WMWidgetView(panel->win), True);
+
+	WMSetWindowCloseAction(panel->win, closeWindow, panel);
+
+	panel->split = WMCreateSplitView(panel->win);
+	WMResizeWidget(panel->split, DEF_WIDTH, DEF_HEIGHT - BUTTON_SPACE_HEIGHT);
+	WMSetSplitViewConstrainProc(panel->split, splitViewConstrainCallback);
+
+	divThickness = WMGetSplitViewDividerThickness(panel->split);
+
+	panel->upperF = WMCreateFrame(panel->win);
+	WMSetFrameRelief(panel->upperF, WRFlat);
+	WMSetViewNotifySizeChanges(WMWidgetView(panel->upperF), True);
+	panel->lowerF = WMCreateFrame(panel->win);
+	/*    WMSetWidgetBackgroundColor(panel->lowerF, WMBlackColor(scr)); */
+	WMSetFrameRelief(panel->lowerF, WRFlat);
+	WMSetViewNotifySizeChanges(WMWidgetView(panel->lowerF), True);
+
+	WMAddSplitViewSubview(panel->split, W_VIEW(panel->upperF));
+	WMAddSplitViewSubview(panel->split, W_VIEW(panel->lowerF));
+
+	WMResizeWidget(panel->upperF, DEF_WIDTH, DEF_UPPER_HEIGHT);
+
+	WMResizeWidget(panel->lowerF, DEF_WIDTH, DEF_LOWER_HEIGHT);
+
+	WMMoveWidget(panel->lowerF, 0, 60 + divThickness);
+
+	white = WMWhiteColor(scr);
+	dark = WMDarkGrayColor(scr);
+
+	panel->sampleT = WMCreateTextField(panel->upperF);
+	WMResizeWidget(panel->sampleT, DEF_WIDTH - 20, 50);
+	WMMoveWidget(panel->sampleT, 10, 10);
+	WMSetTextFieldText(panel->sampleT, _("The quick brown fox jumps over the lazy dog"));
+
+	font = WMBoldSystemFontOfSize(scr, 12);
+
+	panel->famL = WMCreateLabel(panel->lowerF);
+	WMSetWidgetBackgroundColor(panel->famL, dark);
+	WMSetLabelText(panel->famL, _("Family"));
+	WMSetLabelFont(panel->famL, font);
+	WMSetLabelTextColor(panel->famL, white);
+	WMSetLabelRelief(panel->famL, WRSunken);
+	WMSetLabelTextAlignment(panel->famL, WACenter);
+
+	panel->famLs = WMCreateList(panel->lowerF);
+	WMSetListAction(panel->famLs, familyClick, panel);
+
+	panel->typL = WMCreateLabel(panel->lowerF);
+	WMSetWidgetBackgroundColor(panel->typL, dark);
+	WMSetLabelText(panel->typL, _("Typeface"));
+	WMSetLabelFont(panel->typL, font);
+	WMSetLabelTextColor(panel->typL, white);
+	WMSetLabelRelief(panel->typL, WRSunken);
+	WMSetLabelTextAlignment(panel->typL, WACenter);
+
+	panel->typLs = WMCreateList(panel->lowerF);
+	WMSetListAction(panel->typLs, typefaceClick, panel);
+
+	panel->sizL = WMCreateLabel(panel->lowerF);
+	WMSetWidgetBackgroundColor(panel->sizL, dark);
+	WMSetLabelText(panel->sizL, _("Size"));
+	WMSetLabelFont(panel->sizL, font);
+	WMSetLabelTextColor(panel->sizL, white);
+	WMSetLabelRelief(panel->sizL, WRSunken);
+	WMSetLabelTextAlignment(panel->sizL, WACenter);
+
+	panel->sizT = WMCreateTextField(panel->lowerF);
+	/*    WMSetTextFieldAlignment(panel->sizT, WARight); */
+
+	panel->sizLs = WMCreateList(panel->lowerF);
+	WMSetListAction(panel->sizLs, sizeClick, panel);
+
+	WMReleaseFont(font);
+	WMReleaseColor(white);
+	WMReleaseColor(dark);
+
+	panel->setB = WMCreateCommandButton(panel->win);
+	WMResizeWidget(panel->setB, 70, 24);
+	WMMoveWidget(panel->setB, 240, DEF_HEIGHT - (BUTTON_SPACE_HEIGHT - 5));
+	WMSetButtonText(panel->setB, _("Set"));
+	WMSetButtonAction(panel->setB, setClickedAction, panel);
+
+	panel->revertB = WMCreateCommandButton(panel->win);
+	WMResizeWidget(panel->revertB, 70, 24);
+	WMMoveWidget(panel->revertB, 80, DEF_HEIGHT - (BUTTON_SPACE_HEIGHT - 5));
+	WMSetButtonText(panel->revertB, _("Revert"));
+	WMSetButtonAction(panel->revertB, revertClickedAction, panel);
+
+	WMRealizeWidget(panel->win);
+
+	WMMapSubwidgets(panel->upperF);
+	WMMapSubwidgets(panel->lowerF);
+	WMMapSubwidgets(panel->split);
+	WMMapSubwidgets(panel->win);
+
+	WMUnmapWidget(panel->revertB);
+
+	arrangeLowerFrame(panel);
+
+	scr->sharedFontPanel = panel;
+
+	/* register notification observers */
+	WMAddNotificationObserver(notificationObserver, panel,
+				  WMViewSizeDidChangeNotification, WMWidgetView(panel->win));
+	WMAddNotificationObserver(notificationObserver, panel,
+				  WMViewSizeDidChangeNotification, WMWidgetView(panel->upperF));
+	WMAddNotificationObserver(notificationObserver, panel,
+				  WMViewSizeDidChangeNotification, WMWidgetView(panel->lowerF));
+
+	listFamilies(scr, panel);
+
+	return panel;
+}
+
+void WMFreeFontPanel(WMFontPanel * panel)
+{
+	if (panel == WMWidgetScreen(panel->win)->sharedFontPanel) {
+		WMWidgetScreen(panel->win)->sharedFontPanel = NULL;
+	}
+	WMRemoveNotificationObserver(panel);
+	WMUnmapWidget(panel->win);
+	WMDestroyWidget(panel->win);
+	wfree(panel);
+}
+
+void WMShowFontPanel(WMFontPanel * panel)
+{
+	WMMapWidget(panel->win);
+}
+
+void WMHideFontPanel(WMFontPanel * panel)
+{
+	WMUnmapWidget(panel->win);
+}
+
+WMFont *WMGetFontPanelFont(WMFontPanel * panel)
+{
+	return WMGetTextFieldFont(panel->sampleT);
+}
+
+void WMSetFontPanelFont(WMFontPanel * panel, const char *fontName)
+{
+	int fname_len;
+	FcPattern *pattern;
+	FcChar8 *family, *style;
+	double size;
+
+	if (!isXLFD(fontName, &fname_len)) {
+		/* maybe its proper fontconfig and we can parse it */
+		pattern = FcNameParse((const FcChar8 *) fontName);
+	} else {
+		/* maybe its proper xlfd and we can convert it to an FcPattern */
+		pattern = XftXlfdParse(fontName, False, False);
+		/*//FcPatternPrint(pattern); */
+	}
+
+	if (!pattern)
+		return;
+
+	if (FcPatternGetString(pattern, FC_FAMILY, 0, &family) == FcResultMatch)
+		if (FcPatternGetString(pattern, FC_STYLE, 0, &style) == FcResultMatch)
+			if (FcPatternGetDouble(pattern, "pixelsize", 0, &size) == FcResultMatch)
+				setFontPanelFontName(panel, (char *)family, (char *)style, size);
+
+	FcPatternDestroy(pattern);
+}
+
+void WMSetFontPanelAction(WMFontPanel * panel, WMAction2 * action, void *data)
+{
+	panel->action = action;
+	panel->data = data;
+}
+
+static void arrangeLowerFrame(FontPanel * panel)
+{
+	int width = WMWidgetWidth(panel->lowerF) - 55 - 30;
+	int height = WMWidgetHeight(panel->split) - WMWidgetHeight(panel->upperF);
+	int fw, tw, sw;
+
+#define LABEL_HEIGHT 20
+
+	height -= WMGetSplitViewDividerThickness(panel->split);
+
+	height -= LABEL_HEIGHT + 8;
+
+	fw = (125 * width) / 235;
+	tw = (110 * width) / 235;
+	sw = 55;
+
+	WMMoveWidget(panel->famL, 10, 0);
+	WMResizeWidget(panel->famL, fw, LABEL_HEIGHT);
+
+	WMMoveWidget(panel->famLs, 10, 23);
+	WMResizeWidget(panel->famLs, fw, height);
+
+	WMMoveWidget(panel->typL, 10 + fw + 3, 0);
+	WMResizeWidget(panel->typL, tw, LABEL_HEIGHT);
+
+	WMMoveWidget(panel->typLs, 10 + fw + 3, 23);
+	WMResizeWidget(panel->typLs, tw, height);
+
+	WMMoveWidget(panel->sizL, 10 + fw + 3 + tw + 3, 0);
+	WMResizeWidget(panel->sizL, sw + 4, LABEL_HEIGHT);
+
+	WMMoveWidget(panel->sizT, 10 + fw + 3 + tw + 3, 23);
+	WMResizeWidget(panel->sizT, sw + 4, 20);
+
+	WMMoveWidget(panel->sizLs, 10 + fw + 3 + tw + 3, 46);
+	WMResizeWidget(panel->sizLs, sw + 4, height - 23);
+}
+
+#define NUM_FIELDS 14
+
+static int isXLFD(const char *font, int *length_ret)
+{
+	int c = 0;
+
+	*length_ret = 0;
+	while (*font) {
+		(*length_ret)++;
+		if (*font++ == '-')
+			c++;
+	}
+
+	return c == NUM_FIELDS;
+}
+
+typedef struct {
+	char *typeface;
+	WMArray *sizes;
+} Typeface;
+
+typedef struct {
+	char *name;		/* gotta love simplicity */
+	WMArray *typefaces;
+} Family;
+
+static int compare_int(const void *a, const void *b)
+{
+	int i1 = *(int *)a;
+	int i2 = *(int *)b;
+
+	if (i1 < i2)
+		return -1;
+	else if (i1 > i2)
+		return 1;
+	else
+		return 0;
+}
+
+static void addSizeToTypeface(Typeface * face, int size)
+{
+	if (size == 0) {
+		int j;
+
+		for (j = 0; j < wlengthof(scalableFontSizes); j++) {
+			size = scalableFontSizes[j];
+
+			if (!WMCountInArray(face->sizes, (void *)(uintptr_t) size)) {
+				WMAddToArray(face->sizes, (void *)(uintptr_t) size);
+			}
+		}
+		WMSortArray(face->sizes, compare_int);
+	} else {
+		if (!WMCountInArray(face->sizes, (void *)(uintptr_t) size)) {
+			WMAddToArray(face->sizes, (void *)(uintptr_t) size);
+			WMSortArray(face->sizes, compare_int);
+		}
+	}
+}
+
+static void addTypefaceToXftFamily(Family * fam, const char *style)
+{
+	Typeface *face;
+	WMArrayIterator i;
+
+	if (fam->typefaces) {
+		WM_ITERATE_ARRAY(fam->typefaces, face, i) {
+			if (strcmp(face->typeface, style) != 0)
+				continue;	/* go to next interation */
+			addSizeToTypeface(face, 0);
+			return;
+		}
+	} else {
+		fam->typefaces = WMCreateArray(4);
+	}
+
+	face = wmalloc(sizeof(Typeface));
+
+	face->typeface = wstrdup(style);
+	face->sizes = WMCreateArray(4);
+	addSizeToTypeface(face, 0);
+
+	WMAddToArray(fam->typefaces, face);
+}
+
+/*
+ * families (same family name) (Hashtable of family -> array)
+ * 	registries (same family but different registries)
+ *
+ */
+static void addFontToXftFamily(WMHashTable * families, const char *name, const char *style)
+{
+	WMArrayIterator i;
+	WMArray *array;
+	Family *fam;
+
+	array = WMHashGet(families, name);
+	if (array) {
+		WM_ITERATE_ARRAY(array, fam, i) {
+			if (strcmp(fam->name, name) == 0)
+				addTypefaceToXftFamily(fam, style);
+			return;
+		}
+	}
+
+	array = WMCreateArray(8);
+
+	fam = wmalloc(sizeof(Family));
+
+	fam->name = wstrdup(name);
+
+	addTypefaceToXftFamily(fam, style);
+
+	WMAddToArray(array, fam);
+
+	WMHashInsert(families, fam->name, array);
+}
+
+static void listFamilies(WMScreen * scr, WMFontPanel * panel)
+{
+	FcObjectSet *os = 0;
+	FcFontSet *fs;
+	FcPattern *pat;
+	WMHashTable *families;
+	WMHashEnumerator enumer;
+	WMArray *array;
+	int i;
+
+	pat = FcPatternCreate();
+	os = FcObjectSetBuild(FC_FAMILY, FC_STYLE, NULL);
+	fs = FcFontList(0, pat, os);
+	if (!fs) {
+		WMRunAlertPanel(scr, panel->win, _("Error"),
+				_("Could not init font config library\n"), _("OK"), NULL, NULL);
+		return;
+	}
+	if (pat)
+		FcPatternDestroy(pat);
+
+	families = WMCreateHashTable(WMStringPointerHashCallbacks);
+
+	if (fs) {
+		for (i = 0; i < fs->nfont; i++) {
+			FcChar8 *family;
+			FcChar8 *style;
+
+			if (FcPatternGetString(fs->fonts[i], FC_FAMILY, 0, &family) == FcResultMatch)
+				if (FcPatternGetString(fs->fonts[i], FC_STYLE, 0, &style) == FcResultMatch)
+					addFontToXftFamily(families, (char *)family, (char *)style);
+		}
+		FcFontSetDestroy(fs);
+	}
+
+	enumer = WMEnumerateHashTable(families);
+
+	while ((array = WMNextHashEnumeratorItem(&enumer))) {
+		WMArrayIterator i;
+		Family *fam;
+		char buffer[256];
+		WMListItem *item;
+
+		WM_ITERATE_ARRAY(array, fam, i) {
+			wstrlcpy(buffer, fam->name, sizeof(buffer));
+			item = WMAddListItem(panel->famLs, buffer);
+
+			item->clientData = fam;
+		}
+
+		WMFreeArray(array);
+	}
+
+	WMSortListItems(panel->famLs);
+
+	WMFreeHashTable(families);
+}
+
+static void getSelectedFont(FontPanel * panel, char buffer[], int bufsize)
+{
+	WMListItem *item;
+	Family *family;
+	Typeface *face;
+	char *size;
+
+	item = WMGetListSelectedItem(panel->famLs);
+	if (!item)
+		return;
+	family = (Family *) item->clientData;
+
+	item = WMGetListSelectedItem(panel->typLs);
+	if (!item)
+		return;
+	face = (Typeface *) item->clientData;
+
+	size = WMGetTextFieldText(panel->sizT);
+
+	snprintf(buffer, bufsize, "%s:style=%s:pixelsize=%s", family->name, face->typeface, size);
+
+	wfree(size);
+}
+
+static void preview(FontPanel * panel)
+{
+	char buffer[512];
+	WMFont *font;
+
+	getSelectedFont(panel, buffer, sizeof(buffer));
+	font = WMCreateFont(WMWidgetScreen(panel->win), buffer);
+	if (font) {
+		WMSetTextFieldFont(panel->sampleT, font);
+		WMReleaseFont(font);
+	}
+}
+
+static void familyClick(WMWidget * w, void *data)
+{
+	WMList *lPtr = (WMList *) w;
+	WMListItem *item;
+	Family *family;
+	Typeface *face;
+	FontPanel *panel = (FontPanel *) data;
+	WMArrayIterator i;
+	/* current typeface and size */
+	char *oface = NULL;
+	char *osize = NULL;
+	int facei = -1;
+	int sizei = -1;
+
+	/* must try to keep the same typeface and size for the new family */
+	item = WMGetListSelectedItem(panel->typLs);
+	if (item)
+		oface = wstrdup(item->text);
+
+	osize = WMGetTextFieldText(panel->sizT);
+
+	item = WMGetListSelectedItem(lPtr);
+	family = (Family *) item->clientData;
+
+	WMClearList(panel->typLs);
+
+	WM_ITERATE_ARRAY(family->typefaces, face, i) {
+		char buffer[256];
+		int top = 0;
+		WMListItem *fitem;
+
+		wstrlcpy(buffer, face->typeface, sizeof(buffer));
+		if (strcasecmp(face->typeface, "Roman") == 0)
+			top = 1;
+		if (strcasecmp(face->typeface, "Regular") == 0)
+			top = 1;
+		if (top)
+			fitem = WMInsertListItem(panel->typLs, 0, buffer);
+		else
+			fitem = WMAddListItem(panel->typLs, buffer);
+		fitem->clientData = face;
+	}
+
+	if (oface) {
+		facei = WMFindRowOfListItemWithTitle(panel->typLs, oface);
+		wfree(oface);
+	}
+	if (facei < 0) {
+		facei = 0;
+	}
+	WMSelectListItem(panel->typLs, facei);
+	typefaceClick(panel->typLs, panel);
+
+	if (osize) {
+		sizei = WMFindRowOfListItemWithTitle(panel->sizLs, osize);
+	}
+	if (sizei >= 0) {
+		WMSelectListItem(panel->sizLs, sizei);
+		sizeClick(panel->sizLs, panel);
+	}
+
+	if (osize)
+		wfree(osize);
+
+	preview(panel);
+}
+
+static void typefaceClick(WMWidget * w, void *data)
+{
+	FontPanel *panel = (FontPanel *) data;
+	WMListItem *item;
+	Typeface *face;
+	WMArrayIterator i;
+	char buffer[32];
+
+	char *osize = NULL;
+	int sizei = -1;
+	void *size;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) w;
+
+	osize = WMGetTextFieldText(panel->sizT);
+
+	item = WMGetListSelectedItem(panel->typLs);
+	face = (Typeface *) item->clientData;
+
+	WMClearList(panel->sizLs);
+
+	WM_ITERATE_ARRAY(face->sizes, size, i) {
+		if (size != NULL) {
+			int size_int = (intptr_t) size;
+
+			sprintf(buffer, "%i", size_int);
+
+			WMAddListItem(panel->sizLs, buffer);
+		}
+	}
+
+	if (osize) {
+		sizei = WMFindRowOfListItemWithTitle(panel->sizLs, osize);
+	}
+	if (sizei < 0) {
+		sizei = WMFindRowOfListItemWithTitle(panel->sizLs, "12");
+	}
+	if (sizei < 0) {
+		sizei = 0;
+	}
+	WMSelectListItem(panel->sizLs, sizei);
+	WMSetListPosition(panel->sizLs, sizei);
+	sizeClick(panel->sizLs, panel);
+
+	if (osize)
+		wfree(osize);
+
+	preview(panel);
+}
+
+static void sizeClick(WMWidget * w, void *data)
+{
+	FontPanel *panel = (FontPanel *) data;
+	WMListItem *item;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) w;
+
+	item = WMGetListSelectedItem(panel->sizLs);
+	WMSetTextFieldText(panel->sizT, item->text);
+
+	WMSelectTextFieldRange(panel->sizT, wmkrange(0, strlen(item->text)));
+
+	preview(panel);
+}
+
+static void setFontPanelFontName(FontPanel * panel, const char *family, const char *style, double size)
+{
+	int famrow;
+	int stlrow;
+	int sz;
+	char asize[64];
+	void *vsize;
+	WMListItem *item;
+	Family *fam;
+	Typeface *face;
+	WMArrayIterator i;
+
+	famrow = WMFindRowOfListItemWithTitle(panel->famLs, family);
+	if (famrow < 0) {
+		famrow = 0;
+		return;
+	}
+	WMSelectListItem(panel->famLs, famrow);
+	WMSetListPosition(panel->famLs, famrow);
+
+	WMClearList(panel->typLs);
+
+	item = WMGetListSelectedItem(panel->famLs);
+
+	fam = (Family *) item->clientData;
+	WM_ITERATE_ARRAY(fam->typefaces, face, i) {
+		char buffer[256];
+		int top = 0;
+		WMListItem *fitem;
+
+		wstrlcpy(buffer, face->typeface, sizeof(buffer));
+		if (strcasecmp(face->typeface, "Roman") == 0)
+			top = 1;
+		if (top)
+			fitem = WMInsertListItem(panel->typLs, 0, buffer);
+		else
+			fitem = WMAddListItem(panel->typLs, buffer);
+		fitem->clientData = face;
+	}
+
+	stlrow = WMFindRowOfListItemWithTitle(panel->typLs, style);
+
+	if (stlrow < 0) {
+		stlrow = 0;
+		return;
+	}
+
+	WMSelectListItem(panel->typLs, stlrow);
+
+	item = WMGetListSelectedItem(panel->typLs);
+
+	face = (Typeface *) item->clientData;
+
+	WMClearList(panel->sizLs);
+
+	WM_ITERATE_ARRAY(face->sizes, vsize, i) {
+		char buffer[32];
+
+		if (vsize != NULL) {
+			int size_int = (intptr_t) vsize;
+
+			sprintf(buffer, "%i", size_int);
+
+			WMAddListItem(panel->sizLs, buffer);
+		}
+	}
+
+	snprintf(asize, sizeof(asize) - 1, "%d", (int)(size + 0.5));
+
+	sz = WMFindRowOfListItemWithTitle(panel->sizLs, asize);
+
+	if (sz < 0) {
+		return;
+	}
+
+	WMSelectListItem(panel->sizLs, sz);
+	sizeClick(panel->sizLs, panel);
+
+	return;
+}

bazel/WINGs/wframe.c

@@ -0,0 +1,263 @@
+
+#include "WINGs/WINGsP.h"
+
+typedef struct W_Frame {
+	W_Class widgetClass;
+	W_View *view;
+
+	char *caption;
+	WMColor *textColor;
+
+	struct {
+		WMReliefType relief:4;
+		WMTitlePosition titlePosition:4;
+	} flags;
+} Frame;
+
+#define DEFAULT_RELIEF 	WRGroove
+#define DEFAULT_TITLE_POSITION	WTPAtTop
+#define DEFAULT_WIDTH		40
+#define DEFAULT_HEIGHT		40
+
+static void destroyFrame(Frame * fPtr);
+static void paintFrame(Frame * fPtr);
+static void repaintFrame(Frame * fPtr);
+
+void WMSetFrameTitlePosition(WMFrame * fPtr, WMTitlePosition position)
+{
+	fPtr->flags.titlePosition = position;
+
+	if (fPtr->view->flags.realized) {
+		repaintFrame(fPtr);
+	}
+}
+
+void WMSetFrameRelief(WMFrame * fPtr, WMReliefType relief)
+{
+	fPtr->flags.relief = relief;
+
+	if (fPtr->view->flags.realized) {
+		repaintFrame(fPtr);
+	}
+}
+
+void WMSetFrameTitle(WMFrame * fPtr, const char *title)
+{
+	if (fPtr->caption)
+		wfree(fPtr->caption);
+
+	if (title)
+		fPtr->caption = wstrdup(title);
+	else
+		fPtr->caption = NULL;
+
+	if (fPtr->view->flags.realized) {
+		repaintFrame(fPtr);
+	}
+}
+
+static void repaintFrame(Frame * fPtr)
+{
+	W_View *view = fPtr->view;
+	W_Screen *scrPtr = view->screen;
+
+	XClearWindow(scrPtr->display, view->window);
+	paintFrame(fPtr);
+}
+
+static void paintFrame(Frame * fPtr)
+{
+	W_View *view = fPtr->view;
+	W_Screen *scrPtr = view->screen;
+	WMFont *font = scrPtr->normalFont;
+	Display *display = scrPtr->display;
+	int tx, ty, tw, th, tlen;
+	int fy, fh;
+	Bool drawTitle;
+
+	if (fPtr->caption != NULL) {
+		th = WMFontHeight(font);
+		tlen = strlen(fPtr->caption);
+	} else {
+		th = 0;
+		tlen = 0;
+	}
+
+	switch (fPtr->flags.titlePosition) {
+	case WTPAboveTop:
+		ty = 0;
+		fy = th + 4;
+		fh = view->size.height - fy;
+		break;
+
+	case WTPAtTop:
+		ty = 0;
+		fy = th / 2;
+		fh = view->size.height - fy;
+		break;
+
+	case WTPBelowTop:
+		ty = 4;
+		fy = 0;
+		fh = view->size.height;
+		break;
+
+	case WTPAboveBottom:
+		ty = view->size.height - th - 4;
+		fy = 0;
+		fh = view->size.height;
+		break;
+
+	case WTPAtBottom:
+		ty = view->size.height - th;
+		fy = 0;
+		fh = view->size.height - th / 2;
+		break;
+
+	case WTPBelowBottom:
+		ty = view->size.height - th;
+		fy = 0;
+		fh = view->size.height - th - 4;
+		break;
+
+	default:
+		ty = 0;
+		fy = 0;
+		fh = view->size.height;
+	}
+
+	if (tlen > 0 && fPtr->flags.titlePosition != WTPNoTitle) {
+		tw = WMWidthOfString(font, fPtr->caption, tlen);
+
+		tx = (view->size.width - tw) / 2;
+
+		drawTitle = True;
+	} else {
+		tw = tx = 0;
+		drawTitle = False;
+	}
+
+	{
+		XRectangle rect;
+		Region region, tmp;
+		GC gc[4];
+		int i;
+
+		region = XCreateRegion();
+
+		rect.x = 0;
+		rect.y = 0;
+		rect.width = view->size.width;
+		rect.height = view->size.height;
+		XUnionRectWithRegion(&rect, region, region);
+		if (drawTitle) {
+			tmp = XCreateRegion();
+			rect.x = tx;
+			rect.y = ty;
+			rect.width = tw;
+			rect.height = th;
+			XUnionRectWithRegion(&rect, tmp, tmp);
+			XSubtractRegion(region, tmp, region);
+			XDestroyRegion(tmp);
+		}
+		gc[0] = WMColorGC(scrPtr->black);
+		gc[1] = WMColorGC(scrPtr->darkGray);
+		gc[2] = WMColorGC(scrPtr->gray);
+		gc[3] = WMColorGC(scrPtr->white);
+
+		for (i = 0; i < 4; i++) {
+			XSetRegion(display, gc[i], region);
+		}
+		XDestroyRegion(region);
+
+		W_DrawReliefWithGC(scrPtr, view->window, 0, fy, view->size.width, fh,
+				   fPtr->flags.relief, gc[0], gc[1], gc[2], gc[3]);
+
+		for (i = 0; i < 4; i++) {
+			XSetClipMask(display, gc[i], None);
+		}
+	}
+
+	if (drawTitle) {
+		/* can't draw AA text over and over again because it gets messed */
+		/* // TODO create the dbl buffer pixmap when create/set frame title */
+		if (scrPtr->antialiasedText) {
+			Drawable d;
+
+			d = XCreatePixmap(display, view->window, tw, th, scrPtr->depth);
+			XFillRectangle(display, d, WMColorGC(view->backColor), 0, 0, tw, th);
+
+			WMDrawString(scrPtr, d, fPtr->textColor ? fPtr->textColor : scrPtr->black, font, 0, 0, fPtr->caption, tlen);
+			XCopyArea(display, d, view->window, scrPtr->copyGC, 0, 0, tw, th, tx, ty);
+			XFreePixmap(display, d);
+		} else {
+			WMDrawString(scrPtr, view->window, scrPtr->black, font, tx, ty, fPtr->caption, tlen);
+		}
+	}
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	Frame *fPtr = (Frame *) data;
+
+	CHECK_CLASS(data, WC_Frame);
+
+	switch (event->type) {
+	case Expose:
+		if (event->xexpose.count == 0)
+			paintFrame(fPtr);
+		break;
+
+	case DestroyNotify:
+		destroyFrame(fPtr);
+		break;
+	}
+}
+
+void WMSetFrameTitleColor(WMFrame *fPtr, WMColor *color)
+{
+	if (fPtr->textColor)
+		WMReleaseColor(fPtr->textColor);
+	fPtr->textColor = WMRetainColor(color);
+
+	if (fPtr->view->flags.realized) {
+		repaintFrame(fPtr);
+	}
+}
+
+WMFrame *WMCreateFrame(WMWidget * parent)
+{
+	Frame *fPtr;
+
+	fPtr = wmalloc(sizeof(Frame));
+
+	fPtr->widgetClass = WC_Frame;
+
+	fPtr->view = W_CreateView(W_VIEW(parent));
+	if (!fPtr->view) {
+		wfree(fPtr);
+		return NULL;
+	}
+	fPtr->view->self = fPtr;
+	fPtr->textColor = WMRetainColor(fPtr->view->screen->black);
+
+	WMCreateEventHandler(fPtr->view, ExposureMask | StructureNotifyMask, handleEvents, fPtr);
+
+	fPtr->flags.relief = DEFAULT_RELIEF;
+	fPtr->flags.titlePosition = DEFAULT_TITLE_POSITION;
+
+	WMResizeWidget(fPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+
+	return fPtr;
+}
+
+static void destroyFrame(Frame * fPtr)
+{
+	if (fPtr->textColor)
+		WMReleaseColor(fPtr->textColor);
+
+	if (fPtr->caption)
+		wfree(fPtr->caption);
+
+	wfree(fPtr);
+}

bazel/WINGs/winputmethod.c

@@ -0,0 +1,244 @@
+
+#include <X11/Xlib.h>
+
+#include "WINGs/wconfig.h"
+
+#include "WINGs/WINGsP.h"
+
+typedef struct W_IMContext {
+	XIM xim;
+	XIMStyle ximstyle;
+} WMIMContext;
+
+static void instantiateIM_cb(Display * display, XPointer client_data, XPointer call_data)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) display;
+	(void) call_data;
+
+	W_InitIM((W_Screen *) client_data);
+}
+
+static void destroyIM_cb(XIM xim, XPointer client_data, XPointer call_data)
+{
+	W_Screen *scr = (W_Screen *) client_data;
+	W_View *target;
+
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) call_data;
+
+	if (scr->imctx->xim != xim)
+		return;
+
+	target = scr->rootView->childrenList;
+	while (target != NULL) {
+		W_DestroyIC(target);
+		target = target->nextSister;
+	}
+
+	wfree(scr->imctx);
+	scr->imctx = NULL;
+
+	XRegisterIMInstantiateCallback(scr->display, NULL, NULL, NULL, instantiateIM_cb, (XPointer) scr);
+}
+
+void W_InitIM(W_Screen * scr)
+{
+	XIM xim;
+
+	if (scr->imctx)
+		return;
+
+	xim = XOpenIM(scr->display, NULL, NULL, NULL);
+
+	if (xim) {
+		XIMStyles *im_styles;
+		XIMCallback cb;
+		int i;
+
+		scr->imctx = wmalloc(sizeof(WMIMContext));
+		scr->imctx->xim = xim;
+
+		cb.callback = destroyIM_cb;
+		cb.client_data = (XPointer) scr;
+		if (XSetIMValues(scr->imctx->xim, XNDestroyCallback, &cb, NULL))
+			wwarning(_("could not add destroy callback for XIM input method"));
+		XUnregisterIMInstantiateCallback(scr->display, NULL, NULL, NULL, instantiateIM_cb, (XPointer) scr);
+		/* Get available input style */
+		XGetIMValues(scr->imctx->xim, XNQueryInputStyle, &im_styles, NULL);
+
+		scr->imctx->ximstyle = 0;
+
+		for (i = 0; i < im_styles->count_styles && scr->imctx->ximstyle == 0; i++) {
+			if ((im_styles->supported_styles[i] & XIMPreeditPosition) &&
+			    (im_styles->supported_styles[i] & XIMStatusNothing)) {
+				scr->imctx->ximstyle = XIMPreeditPosition | XIMStatusNothing;
+			} else if ((im_styles->supported_styles[i] & XIMPreeditNothing) &&
+				   (im_styles->supported_styles[i] & XIMStatusNothing)) {
+				scr->imctx->ximstyle = XIMPreeditNothing | XIMStatusNothing;
+			}
+		}
+		XFree(im_styles);
+	} else {
+		XRegisterIMInstantiateCallback(scr->display, NULL, NULL, NULL, instantiateIM_cb, (XPointer) scr);
+	}
+}
+
+void W_CreateIC(WMView * view)
+{
+	WMScreen *scr = W_VIEW_SCREEN(view);
+	XVaNestedList preedit_attr = NULL;
+
+	if (view->xic || !view->flags.realized || !scr->imctx)
+		return;
+
+	if (scr->imctx->ximstyle & XIMPreeditPosition) {
+		XPoint spot;
+		XRectangle rect;
+		int ofs;
+
+		ofs = (view->size.height - WMFontHeight(scr->normalFont)) / 2;
+
+		rect.x = ofs;
+		rect.y = ofs;
+		rect.height = WMFontHeight(scr->normalFont);
+		rect.width = view->size.width - ofs * 2;
+		spot.x = rect.x;
+		spot.y = rect.y + rect.height;
+
+		// this really needs to be changed, but I don't know how yet -Dan
+		// it used to be like this with fontsets, but no longer applies to xft
+		preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot,
+						   XNArea, &rect, XNFontInfo, scr->normalFont->font, NULL);
+	}
+
+	view->xic = XCreateIC(scr->imctx->xim, XNInputStyle, scr->imctx->ximstyle,
+			      XNClientWindow, view->window,
+			      preedit_attr ? XNPreeditAttributes : NULL, preedit_attr, NULL);
+
+	if (preedit_attr)
+		XFree(preedit_attr);
+
+	if (view->xic) {
+		unsigned long fevent = 0;
+		XGetICValues(view->xic, XNFilterEvents, &fevent, NULL);
+		XSelectInput(scr->display, view->window,
+			     ButtonPressMask | ButtonReleaseMask | ExposureMask |
+			     KeyPressMask | FocusChangeMask | ButtonMotionMask | fevent);
+	}
+}
+
+void W_DestroyIC(WMView * view)
+{
+	if (view->xic) {
+		XDestroyIC(view->xic);
+		view->xic = 0;
+	}
+}
+
+static void setPreeditArea(W_View * view)
+{
+	WMScreen *scr = W_VIEW_SCREEN(view);
+	XVaNestedList preedit_attr = NULL;
+
+	if (view->xic && (scr->imctx->ximstyle & XIMPreeditPosition)) {
+		XRectangle rect;
+		int ofs;
+
+		ofs = (view->size.height - WMFontHeight(scr->normalFont)) / 2;
+		rect.x = ofs;
+		rect.y = ofs;
+		rect.height = WMFontHeight(scr->normalFont);
+		rect.width = view->size.width - ofs * 2;
+
+		preedit_attr = XVaCreateNestedList(0, XNArea, &rect, NULL);
+		XSetICValues(view->xic, XNPreeditAttributes, preedit_attr, NULL);
+
+		if (preedit_attr) {
+			XFree(preedit_attr);
+		}
+	}
+}
+
+void W_FocusIC(WMView * view)
+{
+	WMScreen *scr = W_VIEW_SCREEN(view);
+
+	if (view->xic) {
+		XSetICFocus(view->xic);
+		XSetICValues(view->xic, XNFocusWindow, view->window, NULL);
+
+		if (scr->imctx->ximstyle & XIMPreeditPosition) {
+			setPreeditArea(view);
+		}
+	}
+}
+
+void W_UnFocusIC(WMView * view)
+{
+	if (view->xic) {
+		XUnsetICFocus(view->xic);
+	}
+}
+
+void W_SetPreeditPositon(W_View * view, int x, int y)
+{
+	WMScreen *scr = W_VIEW_SCREEN(view);
+	XVaNestedList preedit_attr = NULL;
+
+	if (view->xic && (scr->imctx->ximstyle & XIMPreeditPosition)) {
+		XPoint spot;
+		int ofs;
+
+		ofs = (view->size.height - WMFontHeight(scr->normalFont)) / 2;
+		spot.x = x;
+		spot.y = y + view->size.height - ofs - 3;
+		preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);
+		XSetICValues(view->xic, XNPreeditAttributes, preedit_attr, NULL);
+		if (preedit_attr) {
+			XFree(preedit_attr);
+		}
+	}
+}
+
+int W_LookupString(W_View *view, XKeyPressedEvent *event, char *buffer, int buflen, KeySym *keysym, Status *status)
+{
+	WMScreen *scr = W_VIEW_SCREEN(view);
+
+	XSetInputFocus(scr->display, view->window, RevertToParent, CurrentTime);
+
+#ifdef X_HAVE_UTF8_STRING
+	if (view->xic)
+		return Xutf8LookupString(view->xic, event, buffer, buflen, keysym, status);
+#endif
+	return XLookupString(event, buffer, buflen, keysym, (XComposeStatus *) status);
+}
+
+/*
+ * Map a keycode to the corresponding keysym
+ * To replace the deprecated X11 function XKeycodeToKeysym
+ */
+KeySym W_KeycodeToKeysym(Display *display, KeyCode keycode, int index)
+{
+	static int min_kc = -1;
+	static int max_kc;
+	int num_syms;
+	KeySym *key_syms;
+	KeySym ks;
+
+	XDisplayKeycodes(display, &min_kc, &max_kc);
+	if (keycode < min_kc || keycode > max_kc || index < 0) {
+		return NoSymbol;
+	}
+
+	key_syms = XGetKeyboardMapping(display, keycode, 1, &num_syms);
+	if (index >= num_syms) {
+		XFree(key_syms);
+		return NoSymbol;
+	}
+
+	ks = key_syms[index];
+	XFree(key_syms);
+
+	return ks;
+}

bazel/WINGs/wlabel.c

@@ -0,0 +1,214 @@
+
+#include "WINGs/WINGsP.h"
+
+typedef struct W_Label {
+	W_Class widgetClass;
+	W_View *view;
+
+	char *caption;
+
+	WMColor *textColor;
+	WMFont *font;		/* if NULL, use default */
+
+	W_Pixmap *image;
+
+	struct {
+		WMReliefType relief:3;
+		WMImagePosition imagePosition:4;
+		WMAlignment alignment:2;
+
+		unsigned int noWrap:1;
+
+		unsigned int redrawPending:1;
+	} flags;
+} Label;
+
+#define DEFAULT_WIDTH		60
+#define DEFAULT_HEIGHT		14
+#define DEFAULT_ALIGNMENT	WALeft
+#define DEFAULT_RELIEF		WRFlat
+#define DEFAULT_IMAGE_POSITION	WIPNoImage
+
+static void destroyLabel(Label * lPtr);
+static void paintLabel(Label * lPtr);
+
+static void handleEvents(XEvent * event, void *data);
+
+WMLabel *WMCreateLabel(WMWidget * parent)
+{
+	Label *lPtr;
+
+	lPtr = wmalloc(sizeof(Label));
+
+	lPtr->widgetClass = WC_Label;
+
+	lPtr->view = W_CreateView(W_VIEW(parent));
+	if (!lPtr->view) {
+		wfree(lPtr);
+		return NULL;
+	}
+	lPtr->view->self = lPtr;
+
+	lPtr->textColor = WMRetainColor(lPtr->view->screen->black);
+
+	WMCreateEventHandler(lPtr->view, ExposureMask | StructureNotifyMask, handleEvents, lPtr);
+
+	W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+	lPtr->flags.alignment = DEFAULT_ALIGNMENT;
+	lPtr->flags.relief = DEFAULT_RELIEF;
+	lPtr->flags.imagePosition = DEFAULT_IMAGE_POSITION;
+	lPtr->flags.noWrap = 1;
+
+	return lPtr;
+}
+
+void WMSetLabelImage(WMLabel * lPtr, WMPixmap * image)
+{
+	if (lPtr->image != NULL)
+		WMReleasePixmap(lPtr->image);
+
+	if (image)
+		lPtr->image = WMRetainPixmap(image);
+	else
+		lPtr->image = NULL;
+
+	if (lPtr->view->flags.realized) {
+		paintLabel(lPtr);
+	}
+}
+
+WMPixmap *WMGetLabelImage(WMLabel * lPtr)
+{
+	return lPtr->image;
+}
+
+char *WMGetLabelText(WMLabel * lPtr)
+{
+	return lPtr->caption;
+}
+
+void WMSetLabelImagePosition(WMLabel * lPtr, WMImagePosition position)
+{
+	lPtr->flags.imagePosition = position;
+	if (lPtr->view->flags.realized) {
+		paintLabel(lPtr);
+	}
+}
+
+void WMSetLabelTextAlignment(WMLabel * lPtr, WMAlignment alignment)
+{
+	lPtr->flags.alignment = alignment;
+	if (lPtr->view->flags.realized) {
+		paintLabel(lPtr);
+	}
+}
+
+void WMSetLabelRelief(WMLabel * lPtr, WMReliefType relief)
+{
+	lPtr->flags.relief = relief;
+	if (lPtr->view->flags.realized) {
+		paintLabel(lPtr);
+	}
+}
+
+void WMSetLabelText(WMLabel * lPtr, const char *text)
+{
+	if (lPtr->caption)
+		wfree(lPtr->caption);
+
+	if (text != NULL) {
+		lPtr->caption = wstrdup(text);
+	} else {
+		lPtr->caption = NULL;
+	}
+	if (lPtr->view->flags.realized) {
+		paintLabel(lPtr);
+	}
+}
+
+WMFont *WMGetLabelFont(WMLabel * lPtr)
+{
+	return lPtr->font;
+}
+
+void WMSetLabelFont(WMLabel * lPtr, WMFont * font)
+{
+	if (lPtr->font != NULL)
+		WMReleaseFont(lPtr->font);
+	if (font)
+		lPtr->font = WMRetainFont(font);
+	else
+		lPtr->font = NULL;
+
+	if (lPtr->view->flags.realized) {
+		paintLabel(lPtr);
+	}
+}
+
+void WMSetLabelTextColor(WMLabel * lPtr, WMColor * color)
+{
+	if (lPtr->textColor)
+		WMReleaseColor(lPtr->textColor);
+	lPtr->textColor = WMRetainColor(color);
+
+	if (lPtr->view->flags.realized) {
+		paintLabel(lPtr);
+	}
+}
+
+void WMSetLabelWraps(WMLabel * lPtr, Bool flag)
+{
+	flag = ((flag == 0) ? 0 : 1);
+	if (lPtr->flags.noWrap != !flag) {
+		lPtr->flags.noWrap = !flag;
+		if (lPtr->view->flags.realized)
+			paintLabel(lPtr);
+	}
+}
+
+static void paintLabel(Label * lPtr)
+{
+	W_Screen *scrPtr = lPtr->view->screen;
+
+	W_PaintTextAndImage(lPtr->view, !lPtr->flags.noWrap,
+			    lPtr->textColor ? lPtr->textColor : scrPtr->black,
+			    (lPtr->font != NULL ? lPtr->font : scrPtr->normalFont),
+			    lPtr->flags.relief, lPtr->caption,
+			    lPtr->flags.alignment, lPtr->image, lPtr->flags.imagePosition, NULL, 0);
+}
+
+static void handleEvents(XEvent * event, void *data)
+{
+	Label *lPtr = (Label *) data;
+
+	CHECK_CLASS(data, WC_Label);
+
+	switch (event->type) {
+	case Expose:
+		if (event->xexpose.count != 0)
+			break;
+		paintLabel(lPtr);
+		break;
+
+	case DestroyNotify:
+		destroyLabel(lPtr);
+		break;
+	}
+}
+
+static void destroyLabel(Label * lPtr)
+{
+	if (lPtr->textColor)
+		WMReleaseColor(lPtr->textColor);
+
+	if (lPtr->caption)
+		wfree(lPtr->caption);
+
+	if (lPtr->font)
+		WMReleaseFont(lPtr->font);
+
+	if (lPtr->image)
+		WMReleasePixmap(lPtr->image);
+
+	wfree(lPtr);
+}

bazel/WINGs/wmenuitem.c

@@ -0,0 +1,226 @@
+
+#include "WINGs/WINGsP.h"
+
+typedef struct W_MenuItem {
+	char *title;
+
+	WMPixmap *image;
+
+	char *shortcutKey;
+	int shortcutModifierMask;
+
+	WMAction *action;
+	void *data;
+
+	struct W_Menu *submenu;
+
+	void *object;
+
+	WMPixmap *onStateImage;
+	WMPixmap *offStateImage;
+	WMPixmap *mixedStateImage;
+
+	struct {
+		unsigned enabled:1;
+		unsigned state:2;
+	} flags;
+} MenuItem;
+
+WMMenuItem *WMGetSeparatorMenuItem(void)
+{
+	return NULL;
+}
+
+Bool WMMenuItemIsSeparator(WMMenuItem * item)
+{
+	/* Parameter not used, but tell the compiler that it is ok */
+	(void) item;
+
+	return False;
+}
+
+WMMenuItem *WMCreateMenuItem(void)
+{
+	WMMenuItem *item;
+
+	item = wmalloc(sizeof(MenuItem));
+
+	item->flags.enabled = 1;
+
+	return item;
+}
+
+void WMDestroyMenuItem(WMMenuItem * item)
+{
+	if (item->title)
+		wfree(item->title);
+
+	if (item->image)
+		WMReleasePixmap(item->image);
+
+	if (item->shortcutKey)
+		wfree(item->shortcutKey);
+
+	if (item->onStateImage)
+		WMReleasePixmap(item->onStateImage);
+
+	if (item->offStateImage)
+		WMReleasePixmap(item->offStateImage);
+
+	if (item->mixedStateImage)
+		WMReleasePixmap(item->mixedStateImage);
+}
+
+Bool WMGetMenuItemEnabled(WMMenuItem * item)
+{
+	return item->flags.enabled;
+}
+
+void WMSetMenuItemEnabled(WMMenuItem * item, Bool flag)
+{
+	item->flags.enabled = ((flag == 0) ? 0 : 1);
+}
+
+char *WMGetMenuItemShortcut(WMMenuItem * item)
+{
+	return item->shortcutKey;
+}
+
+unsigned WMGetMenuItemShortcutModifierMask(WMMenuItem * item)
+{
+	return item->shortcutModifierMask;
+}
+
+void WMSetMenuItemShortcut(WMMenuItem * item, const char *shortcut)
+{
+	if (item->shortcutKey)
+		wfree(item->shortcutKey);
+
+	item->shortcutKey = wstrdup(shortcut);
+}
+
+void WMSetMenuItemShortcutModifierMask(WMMenuItem * item, unsigned mask)
+{
+	item->shortcutModifierMask = mask;
+}
+
+void *WMGetMenuItemRepresentedObject(WMMenuItem * item)
+{
+	return item->object;
+}
+
+void WMSetMenuItemRepresentedObject(WMMenuItem * item, void *object)
+{
+	item->object = object;
+}
+
+void WMSetMenuItemAction(WMMenuItem * item, WMAction * action, void *data)
+{
+	item->action = action;
+	item->data = data;
+}
+
+WMAction *WMGetMenuItemAction(WMMenuItem * item)
+{
+	return item->action;
+}
+
+void *WMGetMenuItemData(WMMenuItem * item)
+{
+	return item->data;
+}
+
+void WMSetMenuItemTitle(WMMenuItem * item, const char *title)
+{
+	if (item->title)
+		wfree(item->title);
+
+	if (title)
+		item->title = wstrdup(title);
+	else
+		item->title = NULL;
+}
+
+char *WMGetMenuItemTitle(WMMenuItem * item)
+{
+	return item->title;
+}
+
+void WMSetMenuItemState(WMMenuItem * item, int state)
+{
+	item->flags.state = state;
+}
+
+int WMGetMenuItemState(WMMenuItem * item)
+{
+	return item->flags.state;
+}
+
+void WMSetMenuItemPixmap(WMMenuItem * item, WMPixmap * pixmap)
+{
+	if (item->image)
+		WMReleasePixmap(item->image);
+
+	item->image = WMRetainPixmap(pixmap);
+}
+
+WMPixmap *WMGetMenuItemPixmap(WMMenuItem * item)
+{
+	return item->image;
+}
+
+void WMSetMenuItemOnStatePixmap(WMMenuItem * item, WMPixmap * pixmap)
+{
+	if (item->onStateImage)
+		WMReleasePixmap(item->onStateImage);
+
+	item->onStateImage = WMRetainPixmap(pixmap);
+}
+
+WMPixmap *WMGetMenuItemOnStatePixmap(WMMenuItem * item)
+{
+	return item->onStateImage;
+}
+
+void WMSetMenuItemOffStatePixmap(WMMenuItem * item, WMPixmap * pixmap)
+{
+	if (item->offStateImage)
+		WMReleasePixmap(item->offStateImage);
+
+	item->offStateImage = WMRetainPixmap(pixmap);
+}
+
+WMPixmap *WMGetMenuItemOffStatePixmap(WMMenuItem * item)
+{
+	return item->offStateImage;
+}
+
+void WMSetMenuItemMixedStatePixmap(WMMenuItem * item, WMPixmap * pixmap)
+{
+	if (item->mixedStateImage)
+		WMReleasePixmap(item->mixedStateImage);
+
+	item->mixedStateImage = WMRetainPixmap(pixmap);
+}
+
+WMPixmap *WMGetMenuItemMixedStatePixmap(WMMenuItem * item)
+{
+	return item->mixedStateImage;
+}
+
+#if 0
+void WMSetMenuItemSubmenu(WMMenuItem * item, WMMenu * submenu)
+{
+	item->submenu = submenu;
+}
+
+WMMenu *WMGetMenuItemSubmenu(WMMenuItem * item)
+{
+	return item->submenu;
+}
+
+Bool WMGetMenuItemHasSubmenu(WMMenuItem * item)
+{
+	return item->submenu != NULL;
+}
+#endif