* Mon Jan 25 2010 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20100125
- Add over-the-spot editing mode.
- Possible fixed of Google issue 505: ibus acts strange in Qt programs.
- Implemented Google issue 738:  Add a mode that allow editing in candidate window
  (thus over-the-spot mode).

* Fri Dec 11 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20091211
- Fix Google issue 608: ibus-chewing does not show cursor in xim mode.
- Fix Google issue 611: ibus-chewing keyboard setting reverts to default unexpectlly.
- Fix Google issue 660: failed to build with binutils-gold.
- Remove make target commit.
- Add make target tag

* Fri Oct 02 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20091002
- Bug 518901 - ibus-chewing would not work with locale zh_TW.Big
- Fix Google issue 501: ibus-chewing buffer doesn't get cleared when
toggling ibus on/off
- Fix Google issue 502: ibus-chewing: character selection window stays
behind when toggling ibus off- Use WM's revised ibus-chewing icon.
- Debug output now marked with levels.

* Thu Sep 17 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20090917
- Addressed Upstream (IBUS Google code) issue 484:
  + Find the source that why the / and . are not working.
- Pack the gob2 generation source to avoid the [Bug 519108]:
  [gob2] class and enum names convert incorrectly in mock / koji.

* Wed Sep 09 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20090831
- IBusProperty and IBusPropList are free upon destruction.
- Fixed Red Hat Bugzilla [Bug 519328] [ibus-chewing] inconsistent between normal mode and plain Zhuyin mode.
- Addressed Upstream (IBUS Google code) issue 484:
  Arithmetic symbols (+-*/) on number pad does not input properly.

* Wed Aug 26 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20090818
- Merged 1.2 and 1.1 source code.
- Addressed Upstream (IBUS Google code) issue 471.
- Remove libX11 dependency.

* Mon Aug 17 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20090624
- Lookup table now shows the selection key.

* Mon Jun 22 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.2.0.20090622
- For IBus 1.2
- Revised dialog look.

* Fri May 22 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.0.10.20090523
- Applied Lubomir Rintel's patch

* Fri May 22 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.0.10.20090522
- Now the 1st down key brings the longest possible phrases.
  The 2nd down key brings the 2nd longest possible phrases from the back,
  unlike the previous versions where the cursor stays in the head of longest phrase.
- Add force lowercase in English mode option.
- Fix double free issue when destroy ibus-chewing.
- Hide ibus-chewing-panel when ibus-chewing is focus-out

* Mon May 11 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.0.9.20090508
  Now commit is forced when switch of ibus-chewing or current application loses focus.
- New ibus-chewing.png is contribute by WM.
- input-keyboard.png is no longer needed and removed.
- ibus-engine-chewing -v option now need an integer as verbose level.
- ibus-chewing.schemas is now generated.
- Fix some CMake modules bugs.

* Tue Apr 28 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.0.8.20090428
Fix the errors which Funda Wang as pointing out:
- Move src/chewing.xml.in to data/
- Fixed some typo in next_version targets.
- Remove GConf2 package requirement, while add gconftool-2 requirement.

* Mon Mar 30 2009 - Ding-Yi Chen <dchen at redhat.com> - 1.0.5.20090330
- Added tooltips.
- Revealed the sync caps lock setting.
- Fixed Right key bug.
- Added CMake policy 0011 as OLD.

* Mon Mar 23 2009 Ding-Yi Chen <dchen at redhat.com> - 1.0.4.20090323
- Various Settings are now in dialog.
- Integer settings are now revealed.
- MakerDialog.gob is now available.
- Work around of easy symbol input.
- Fix iBus Google issue 310.

* Wed Mar 11 2009 Ding-Yi Chen <dchen at redhat.com> - 1.0.3.20090311
- IBus Google issue 305:  ibus-chewing.schema -> ibus-chewing.schemas
- IBus Google issue 307:  hardcoded chewing datadir
- Sync chewing candPerPage and IBusTable->page_size
- Sync between IM and keyboard (Experimental)

* Tue Mar 03 2009 Ding-Yi Chen <dchen at redhat.com> - 1.0.2.20090303
- Required gconf2 -> GConf2.
- Fix RPM scriptlet.

* Fri Feb 27 2009 Ding-Yi Chen <dchen at redhat.com> - 1.0.1.20090227
- Add gconf schema.
- Fix some memory leaking checked.
- Move some function to cmake_modules.
- Fix Google code issue 281

* Fri Feb 20 2009 - Ding-Yi Chen <dchen at redhat.com>  - 1.0.0.20090220
- This is a barely working version for with IBus C.
- The build system is converted from autotool to CMake.




