dlls/infosoft/wordbreaker.c

   1 /*
   2  *    Word splitter Implementation
   3  *
   4  * Copyright 2006 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winreg.h"
  31 #include "ole2.h"
  32 #include "indexsrv.h"
  33 #include "wine/unicode.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(infosoft);
  37
  38 typedef struct tag_wordbreaker_impl
  39 {
  40     const IWordBreakerVtbl *lpVtbl;
  41     LONG ref;
  42 } wordbreaker_impl;
  43
  44 static HRESULT WINAPI wb_QueryInterface( IWordBreaker *iface,
  45         REFIID riid, LPVOID *ppvObj)
  46 {
  47     wordbreaker_impl *This = (wordbreaker_impl *)iface;
  48
  49     TRACE("(%p)->(%s)\n",This,debugstr_guid(riid));
  50
  51     *ppvObj = NULL;
  52
  53     if (IsEqualIID(riid, &IID_IUnknown) ||
  54         IsEqualIID(riid, &IID_IWordBreaker))
  55     {
  56         *ppvObj = This;
  57         return S_OK;
  58     }
  59
  60     TRACE("-- E_NOINTERFACE\n");
  61     return E_NOINTERFACE;
  62 }
  63
  64 static ULONG WINAPI wb_AddRef( IWordBreaker *iface )
  65 {
  66     wordbreaker_impl *This = (wordbreaker_impl *)iface;
  67     return InterlockedIncrement(&This->ref);
  68 }
  69
  70 static ULONG WINAPI wb_Release(IWordBreaker *iface)
  71 {
  72     wordbreaker_impl *This = (wordbreaker_impl *)iface;
  73     LONG refcount;
  74
  75     refcount = InterlockedDecrement(&This->ref);
  76     if (!refcount)
  77         HeapFree(GetProcessHeap(), 0, This);
  78
  79     return refcount;
  80 }
  81
  82 static HRESULT WINAPI wb_Init( IWordBreaker *iface,
  83         BOOL fQuery, ULONG ulMaxTokenSize, BOOL *pfLicense )
  84 {
  85     TRACE("%d %u\n", fQuery, ulMaxTokenSize);
  86     *pfLicense = FALSE;
  87     return S_OK;
  88 }
  89
  90 static HRESULT call_sink( IWordSink *pWordSink, TEXT_SOURCE *ts, UINT len )
  91 {
  92     HRESULT r;
  93
  94     if (!len)
  95         return S_OK;
  96
  97     TRACE("%d %s\n", len, debugstr_w(&ts->awcBuffer[ts->iCur]));
  98
  99     r = IWordSink_PutWord( pWordSink, len, &ts->awcBuffer[ts->iCur], len, ts->iCur );
 100     ts->iCur += len;
 101
 102     return r;
 103 }
 104
 105 static HRESULT WINAPI wb_BreakText( IWordBreaker *iface,
 106          TEXT_SOURCE *ts, IWordSink *pWordSink, IPhraseSink *pPhraseSink)
 107 {
 108     UINT len, state = 0;
 109     WCHAR ch;
 110
 111     TRACE("%p %p %p\n", ts, pWordSink, pPhraseSink);
 112
 113     if (pPhraseSink)
 114         FIXME("IPhraseSink won't be called\n");
 115
 116     do
 117     {
 118         len = 0;
 119         while ((ts->iCur + len) < ts->iEnd)
 120         {
 121             ch = ts->awcBuffer[ts->iCur + len];
 122
 123             switch (state)
 124             {
 125             case 0: /* skip spaces and punctuation */
 126
 127                 if (!ch || ispunctW(ch) || isspaceW(ch))
 128                     ts->iCur ++;
 129                 else
 130                     state = 1;
 131                 break;
 132
 133             case 1: /* find the end of the word */
 134
 135                 if (ch && !ispunctW(ch) && !isspaceW(ch))
 136                     len++;
 137                 else
 138                 {
 139                     call_sink( pWordSink, ts, len );
 140                     len = 0;
 141                     state = 0;
 142                 }
 143                 break;
 144
 145             }
 146         }
 147         call_sink( pWordSink, ts, len );
 148
 149     } while (S_OK == ts->pfnFillTextBuffer( ts ));
 150
 151     return S_OK;
 152 }
 153
 154 static HRESULT WINAPI wb_ComposePhrase( IWordBreaker *iface,
 155          const WCHAR *pwcNoun, ULONG cwcNoun,
 156          const WCHAR *pwcModifier, ULONG cwcModifier,
 157          ULONG ulAttachmentType, WCHAR *pwcPhrase, ULONG *pcwcPhrase)
 158 {
 159     FIXME("%p %u %p %u %u %p %p\n", pwcNoun, cwcNoun,
 160           pwcModifier, cwcModifier, ulAttachmentType, pwcPhrase, pcwcPhrase);
 161     return S_OK;
 162 }
 163
 164 static HRESULT WINAPI wb_GetLicenseToUse( IWordBreaker *iface, const WCHAR **ppwcsLicense )
 165 {
 166     FIXME("%p\n", ppwcsLicense);
 167     *ppwcsLicense = NULL;
 168     return S_OK;
 169 }
 170
 171 static const IWordBreakerVtbl wordbreaker_vtbl =
 172 {
 173     wb_QueryInterface,
 174     wb_AddRef,
 175     wb_Release,
 176     wb_Init,
 177     wb_BreakText,
 178     wb_ComposePhrase,
 179     wb_GetLicenseToUse,
 180 };
 181
 182 HRESULT WINAPI wb_Constructor(IUnknown* pUnkOuter, REFIID riid, LPVOID *ppvObject)
 183 {
 184     wordbreaker_impl *This;
 185     IWordBreaker *wb;
 186
 187     TRACE("%p %s %p\n", pUnkOuter, debugstr_guid(riid), ppvObject);
 188
 189     This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
 190     if (!This)
 191         return E_OUTOFMEMORY;
 192
 193     This->ref = 1;
 194     This->lpVtbl = &wordbreaker_vtbl;
 195
 196     wb = (IWordBreaker*) This;
 197
 198     return IWordBreaker_QueryInterface(wb, riid, ppvObject);
 199 }