← Back to branch summary

~ubuntu-branches/debian/experimental/cuneiform/experimental

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rselstr/sources/src/cpp/seform.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2009-07-10 17:58:10 UTC
  • Revision ID: james.westby@ubuntu.com-20090710175810-rqc89d2i3tki9m89
Tags: upstream-0.7.0+dfsg
ImportĀ upstreamĀ versionĀ 0.7.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/rselstr/sources/src/cpp/seform.cpp
 
1
/*
 
2
Copyright (c) 1993-2008, Cognitive Technologies
 
3
All rights reserved.
 
4
 
 
5
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½,
 
6
ļæ½ļæ½ļæ½ ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½:
 
7
 
 
8
      * ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
9
        ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
10
        ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
 
11
      * ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½
 
12
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
13
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½
 
14
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
 
15
      * ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ Cognitive Technologies, ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½
 
16
        ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
17
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
18
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
 
19
 
 
20
ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ "ļæ½ļæ½ļæ½
 
21
ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½" ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½-ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½,
 
22
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ ļæ½ļæ½
 
23
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½. ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
24
ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½
 
25
ļæ½ļæ½ŃØļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½
 
26
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
27
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ (ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½,
 
28
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½-ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
29
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½,
 
30
ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½), ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½
 
31
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
 
32
 
 
33
Redistribution and use in source and binary forms, with or without modification,
 
34
are permitted provided that the following conditions are met:
 
35
 
 
36
    * Redistributions of source code must retain the above copyright notice,
 
37
      this list of conditions and the following disclaimer.
 
38
    * Redistributions in binary form must reproduce the above copyright notice,
 
39
      this list of conditions and the following disclaimer in the documentation
 
40
      and/or other materials provided with the distribution.
 
41
    * Neither the name of the Cognitive Technologies nor the names of its
 
42
      contributors may be used to endorse or promote products derived from this
 
43
      software without specific prior written permission.
 
44
 
 
45
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
46
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
47
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
48
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 
49
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
50
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
51
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 
52
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 
53
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
54
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
55
*/
 
56
 
 
57
/*
 
58
  ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
59
  ļæ½ļæ½                                                              ļæ½ļæ½
 
60
  ļæ½ļæ½     Copyright (C) 1990 Cognitive Technology Corporation.     ļæ½ļæ½
 
61
  ļæ½ļæ½     All rights reserved. This program is proprietary and     ļæ½ļæ½
 
62
  ļæ½ļæ½     a trade secret of Cognitive Technology Corporation.      ļæ½ļæ½
 
63
  ļæ½ļæ½                                                              ļæ½ļæ½
 
64
  ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
65
*/
 
66
 
 
67
/****************************************************************************
 
68
 *                                                                          *
 
69
 *              S T R I N G S   E X T R A C T I O N                         *
 
70
 *                                                                          *
 
71
 *              Written in 1991 by Yuri Panchul                             *
 
72
 *                                                                          *
 
73
 *              SESTRING.C - working with string data                       *
 
74
 *                                                                          *
 
75
 *              07/27/92 - insert checking nSpecialsLetters == nLetters     *
 
76
 *                         into StringCalculateParameters                   *
 
77
 *                                                                          *
 
78
 ***************************************************************************/
 
79
 
 
80
# include <stdlib.h>
 
81
# include "extract.h"
 
82
# include "func.h"
 
83
# include "my_mem.h"
 
84
# include "newfunc.h"
 
85
 
 
86
# include "dpuma.h"
 
87
# include "cstr.h"
 
88
 
 
89
#include "minmax.h"
 
90
 
 
91
int nCurrentFillingRoots;
 
92
 
 
93
 
 
94
Bool32 StringsUpdatedByBukvica()
 
95
{
 
96
        STRING* p;
 
97
        int nString;
 
98
        Word32 key = 111;
 
99
        Word32 color = 23000;
 
100
 
 
101
        for (nString = 0, p = pStringsUpList; p != NULL; p = p -> pDown, nString++)
 
102
    {
 
103
                if((p->nLetters == 1)&&((&pRoots [p -> pLettersList [0]])->nHeight >64))
 
104
                {
 
105
                        int data = 0;
 
106
                        CCOM_USER_BLOCK uBlock;
 
107
 
 
108
                        uBlock.code = CCOM_UB_CAPDROPLN;
 
109
                        uBlock.data = (Word8*)&data;
 
110
 
 
111
                        if((p->pUp!=NULL)||(p->pDown!=NULL))
 
112
                        {
 
113
                                if(p->pUp == NULL)
 
114
                                {
 
115
                                        *(int*)uBlock.data = nString+1;
 
116
                                }
 
117
                                else
 
118
                                {
 
119
                                        if(p->pDown == NULL)
 
120
                                        {
 
121
                                                *(int*)uBlock.data = nString-1;
 
122
                                        }
 
123
                                        else
 
124
                                        {
 
125
                                                if(abs(p->pUp->yTop - p->yTop)<=abs(p->pDown->yTop - p->yTop))
 
126
                                                {
 
127
                                                        *(int*)uBlock.data = nString-1;
 
128
                                                }
 
129
                                                else
 
130
                                                {
 
131
                                                        *(int*)uBlock.data = nString+1;
 
132
                                                }
 
133
                                        }
 
134
                                }
 
135
                                p->uFlags += CSTR_STR_CapDrop;
 
136
                        }
 
137
 
 
138
                        uBlock.size = sizeof(data);
 
139
                        CCOM_SetUserBlock((CCOM_comp*)(pRoots [p -> pLettersList [0]]).pComp, &uBlock);
 
140
 
 
141
                }
 
142
        }
 
143
 
 
144
        return TRUE;
 
145
}
 
146
 
 
147
void StringCalculateParameters (STRING *pString)
 
148
{
 
149
    int i;
 
150
    ROOT *pRoot;
 
151
    int  nSumHeight;
 
152
    int  ySumTop;
 
153
    int  nSumTopDispersion;
 
154
    int  nSumBottomDispersion;
 
155
    BOOL bSpecialFound;
 
156
 
 
157
    pString -> language = pCurrentBlock -> language; // Pit 02-??-94
 
158
 
 
159
    if (pString -> nLetters == 0)
 
160
    {
 
161
        pString -> nMiddleHeight     = 0;
 
162
        pString -> yMiddleTop        = 0;
 
163
        pString -> yMiddleBottom     = 0;
 
164
        pString -> nTopDispersion    = 0;
 
165
        pString -> nBottomDispersion = 0;
 
166
        pString -> yMin              = 0;
 
167
        pString -> yMax              = 0;
 
168
        return;
 
169
    }
 
170
 
 
171
    pString -> nSpecialsLetters = 0;
 
172
 
 
173
  AGAIN:
 
174
    nSumHeight = 0;
 
175
    ySumTop    = 0;
 
176
 
 
177
    for (i = 0; i < pString -> nLetters; i++)
 
178
    {
 
179
        pRoot = pRoots + pString -> pLettersList [i];
 
180
 
 
181
        if (pRoot -> bType & (ROOT_SPECIAL_LETTER | ROOT_SPECIAL_DUST))
 
182
            continue;
 
183
 
 
184
        nSumHeight     += pRoot -> nHeight;
 
185
        ySumTop        += pRoot -> yRow;
 
186
    }
 
187
 
 
188
    pString -> nMiddleHeight = nSumHeight
 
189
                / (pString -> nLetters - pString -> nSpecialsLetters);
 
190
    pString -> yMiddleTop    = ySumTop
 
191
                / (pString -> nLetters - pString -> nSpecialsLetters);
 
192
    pString -> yMiddleBottom = (ySumTop + nSumHeight)
 
193
                / (pString -> nLetters - pString -> nSpecialsLetters);
 
194
    pString -> yMiddleLine   =
 
195
        (pString -> yMiddleTop + pString -> yMiddleBottom) / 2;
 
196
 
 
197
    nSumTopDispersion    = 0;
 
198
    nSumBottomDispersion = 0;
 
199
 
 
200
    for (i = 0; i < pString -> nLetters; i++)
 
201
    {
 
202
        pRoot = pRoots + pString -> pLettersList [i];
 
203
 
 
204
        if (pRoot -> bType & (ROOT_SPECIAL_LETTER | ROOT_SPECIAL_DUST))
 
205
            continue;
 
206
 
 
207
        nSumTopDispersion +=
 
208
            (pRoot -> yRow - pString -> yMiddleTop) *
 
209
            (pRoot -> yRow - pString -> yMiddleTop);
 
210
 
 
211
        nSumBottomDispersion +=
 
212
            (pRoot -> yRow + pRoot -> nHeight - pString -> yMiddleBottom) *
 
213
            (pRoot -> yRow + pRoot -> nHeight - pString -> yMiddleBottom);
 
214
    }
 
215
 
 
216
    pString -> nTopDispersion =
 
217
        (int) long_sqrt ((LONG) (nSumTopDispersion
 
218
                      / (pString -> nLetters - pString -> nSpecialsLetters)));
 
219
 
 
220
    pString -> nBottomDispersion =
 
221
        (int) long_sqrt ((LONG) (nSumBottomDispersion
 
222
                      / (pString -> nLetters - pString -> nSpecialsLetters)));
 
223
 
 
224
    pString -> yMin = pString -> yMiddleTop
 
225
                      - MAX (2 * pString -> nTopDispersion,
 
226
                             3 * pString -> nMiddleHeight / 4);
 
227
 
 
228
    pString -> yMax = pString -> yMiddleBottom
 
229
                      + MAX (2 * pString -> nBottomDispersion,
 
230
                             3 * pString -> nMiddleHeight / 4);
 
231
 
 
232
    bSpecialFound = FALSE;
 
233
 
 
234
    for (i = 0; i < pString -> nLetters; i++)
 
235
    {
 
236
        pRoot = pRoots + pString -> pLettersList [i];
 
237
 
 
238
        if (pRoot -> bType & (ROOT_SPECIAL_LETTER | ROOT_SPECIAL_DUST))
 
239
            continue;
 
240
 
 
241
        if (pRoot -> yRow                        > pString -> yMiddleLine ||
 
242
            pRoot -> yRow + pRoot -> nHeight - 1 < pString -> yMiddleLine)
 
243
        {
 
244
            pRoot -> bType |= ROOT_SPECIAL_DUST;
 
245
            bSpecialFound = TRUE;
 
246
            pString -> nSpecialsLetters++;
 
247
        }
 
248
        else if (pRoot -> yRow                        < pString -> yMin ||
 
249
                 pRoot -> yRow + pRoot -> nHeight - 1 > pString -> yMax)
 
250
        {
 
251
            pRoot -> bType |= ROOT_SPECIAL_LETTER;
 
252
            bSpecialFound = TRUE;
 
253
            pString -> nSpecialsLetters++;
 
254
        }
 
255
 
 
256
    }
 
257
 
 
258
    if (! bSpecialFound)
 
259
        return;
 
260
 
 
261
    if (pString -> nSpecialsLetters == pString -> nLetters)
 
262
    {
 
263
        for (i = 0; i < pString -> nLetters; i++)
 
264
        {
 
265
            pRoot = pRoots + pString -> pLettersList [i];
 
266
 
 
267
            if (pRoot -> bType & ROOT_SPECIAL_LETTER)
 
268
            {
 
269
                pRoot -> bType &= ~(ROOT_SPECIAL_LETTER | ROOT_SPECIAL_DUST);
 
270
                pString -> nSpecialsLetters--;
 
271
            }
 
272
        }
 
273
    }
 
274
 
 
275
    if (pString -> nSpecialsLetters == pString -> nLetters)
 
276
                return; // Piter 22.02.00
 
277
 
 
278
    goto AGAIN;
 
279
}
 
280
 
 
281
void StringsFill (void)
 
282
{
 
283
    ROOT *pRoot;
 
284
    int  iMax;
 
285
    int  i;
 
286
    int  y;
 
287
    BOOL    CorrectHist=FALSE;
 
288
 
 
289
    for (;;)
 
290
    {
 
291
# ifdef SE_DEBUG
 
292
        if (SE_DebugGraphicsLevel >= 4)
 
293
            BlockHystogramShow (pCurrentBlock);
 
294
# endif
 
295
 
 
296
        iMax = 0;
 
297
 
 
298
        for (i = 0; i < pCurrentBlock -> nHystColumns; i++)
 
299
        {
 
300
            if (pCurrentBlock -> pHystogram [i]
 
301
                   > pCurrentBlock -> pHystogram [iMax])
 
302
            {
 
303
                iMax = i;
 
304
            }
 
305
        }
 
306
 
 
307
        if (pCurrentBlock -> pHystogram [iMax] == 0)
 
308
            break;
 
309
 
 
310
        y = pCurrentBlock -> Rect.yTop + iMax;
 
311
 
 
312
        StringNewDescriptor ();
 
313
 
 
314
        for (CorrectHist=FALSE,pRoot = pCurrentBlock -> pRoots;
 
315
                 pRoot != NULL;
 
316
                     pRoot = pRoot -> u1.pNext)
 
317
        {
 
318
            if (pRoot -> bType & ROOT_USED)
 
319
                continue;
 
320
 
 
321
                        if (IS_LAYOUT_DUST (*pRoot))
 
322
                continue;
 
323
 
 
324
            if (pRoot -> yRow <= y &&
 
325
                pRoot -> yRow + pRoot -> nHeight > y)
 
326
            {
 
327
 
 
328
                StringAddLetter1 (pRoot - pRoots);
 
329
                pRoot -> bType |= ROOT_USED;
 
330
 
 
331
                BlockHystogramDiscountRoot (pCurrentBlock, pRoot);
 
332
                CorrectHist=TRUE;
 
333
            }
 
334
        }
 
335
        if( !CorrectHist ) // Oleg & Pit : ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ UPIC31
 
336
            break;
 
337
        StringCalculateParameters (&String);
 
338
 
 
339
# ifdef SE_DEBUG
 
340
        if (SE_DebugGraphicsLevel >= 4)
 
341
            LT_GraphicsCurrentStringOutput ("Current string");
 
342
# endif
 
343
        StringSortLetters (&String);
 
344
        StringAddToList ();
 
345
 
 
346
        nCurrentFillingRoots += String.nLetters;
 
347
        progress_set_percent (nCurrentFillingRoots * 100 / nRoots);
 
348
    }
 
349
}
 
350
 
 
351
void StringsListEdit (void)
 
352
{
 
353
    STRING *p, *q;
 
354
 
 
355
  AGAIN_P:
 
356
    for (p = pStringsList; p != NULL; p = p -> pNext)
 
357
    {
 
358
        if(p->nUserNum != IS_IN_TABLE)
 
359
        {
 
360
        if (p -> nRecognized  == 0  &&
 
361
            p -> yBottom - p -> yTop + 1 < pCurrentBlock -> nAverageHeight)
 
362
        {
 
363
            if (p == pStringsList)
 
364
                {
 
365
                  StringRemove (p);
 
366
                  goto AGAIN_P;
 
367
                }
 
368
            else if (p == pStringsListEnd)
 
369
                {
 
370
                   StringRemove (p);
 
371
                   break;
 
372
                }
 
373
            else
 
374
                {
 
375
                    p = p -> pPrev;
 
376
                    StringRemove (p -> pNext);
 
377
                 }
 
378
        }
 
379
        }
 
380
 
 
381
      AGAIN_Q:
 
382
        for (q = p -> pNext; q != NULL; q = q -> pNext)
 
383
        {
 
384
            if (StringIncludes (p, q))
 
385
            {
 
386
                if (q -> xLeft < p -> xLeft)
 
387
                    p -> xLeft = q -> xLeft;
 
388
 
 
389
                if (q -> xRight > q -> xRight)
 
390
                    p -> xRight = q -> xRight;
 
391
                StringRemove (q);
 
392
                goto AGAIN_Q;
 
393
            }
 
394
        }
 
395
    }
 
396
}
 
397
 
 
398
static int nStripHeight;
 
399
static int nDustUpper, nDustLower;
 
400
static int nDustLeft, nDustRight;
 
401
static int nDustGap;
 
402
 
 
403
static BOOL PassForDust (STRING *pString, ROOT *pRootsBegin, ROOT *pRootsAfter)
 
404
{
 
405
    BOOL bStripWasExpanded = FALSE;
 
406
    ROOT *pRoot;
 
407
 
 
408
    for (pRoot = pRootsBegin; pRoot < pRootsAfter; pRoot++)
 
409
    {
 
410
        if (pRoot -> nBlock != nCurrentBlock &&
 
411
            pRoot -> nBlock != 0)
 
412
        {
 
413
            continue;
 
414
        }
 
415
 
 
416
        if ((pRoot -> bType & ROOT_USED)                      ||
 
417
            (pRoot -> bType & ROOT_SPECIAL_LETTER)            ||
 
418
            pRoot -> yRow                        > nDustLower ||
 
419
            pRoot -> yRow + pRoot -> nHeight - 1 < nDustUpper)
 
420
        {
 
421
            continue;
 
422
        }
 
423
 
 
424
        if (pRoot -> xColumn < nDustLeft)
 
425
        {
 
426
            if (nDustLeft - (pRoot -> xColumn + pRoot -> nWidth)
 
427
                    >= nDustGap)
 
428
            {
 
429
                continue;
 
430
            }
 
431
 
 
432
            nDustLeft         = pRoot -> xColumn;
 
433
            bStripWasExpanded = TRUE;
 
434
        }
 
435
 
 
436
        if (pRoot -> xColumn + pRoot -> nWidth - 1 > nDustRight)
 
437
        {
 
438
            if (pRoot -> xColumn - nDustRight >= nDustGap)
 
439
            {
 
440
                continue;
 
441
            }
 
442
 
 
443
            nDustRight        = pRoot -> xColumn + pRoot -> nWidth - 1;
 
444
            bStripWasExpanded = TRUE;
 
445
        }
 
446
 
 
447
        pRoot -> bType |= ROOT_USED;
 
448
        StringAddDust2 (pString, pRoot - pRoots);
 
449
    }
 
450
 
 
451
    return (bStripWasExpanded);
 
452
}
 
453
 
 
454
void StringDustAccount (STRING *pString)
 
455
{
 
456
    int i;
 
457
    ROOT *pLocalRootsBegin, *pLocalRootsAfter;
 
458
    BOOL bExpanded1, bExpanded2;
 
459
 
 
460
    nStripHeight = pString -> yBottom - pString -> yTop + 1;
 
461
    nDustUpper   = pString -> yTop - nStripHeight / 2;
 
462
    nDustLower   = pString -> yBottom + nStripHeight / 2;
 
463
    nDustLeft    = pString -> xLeft;
 
464
    nDustRight   = pString -> xRight;
 
465
    nDustGap     = nDustLower - nDustUpper + 1;
 
466
 
 
467
    RootStripsGetLoopParameters
 
468
    (
 
469
        nDustUpper,
 
470
        nDustLower,
 
471
        &pLocalRootsBegin,
 
472
        &pLocalRootsAfter
 
473
    );
 
474
 
 
475
    if (pLocalRootsBegin == NULL)
 
476
        return;
 
477
 
 
478
    do
 
479
    {
 
480
        bExpanded1 = PassForDust (pString, pLocalRootsBegin, pLocalRootsAfter);
 
481
        bExpanded2 = PassForDust (pString, pAfterOriginalRoots, pAfterRoots);
 
482
    }
 
483
    while (bExpanded1 || bExpanded2);
 
484
 
 
485
    for (i = 0; i < pString -> nDust; i++)
 
486
        pRoots [pString -> pDustList [i]].bType &= ~ROOT_USED;
 
487
 
 
488
    StringSortDust (pString);
 
489
}
 
490
 
 
491
void StringsDustAccount (void)
 
492
{
 
493
    STRING *pString;
 
494
 
 
495
    for (pString = pStringsList; pString != NULL; pString = pString -> pNext)
 
496
    {
 
497
/*  STDD19 !!!
 
498
        if (! (pString -> uFlags & SF_SPECIAL))
 
499
            StringDustAccount (pString);
 
500
*/
 
501
        StringDustAccount (pString);
 
502
    }
 
503
}
 
504
 
 
505
BOOL StringIsTrash (STRING *pString)
 
506
{
 
507
    int nBigDust;
 
508
    int nBigDustHeight;
 
509
    int i;
 
510
    ROOT *pRoot;
 
511
 
 
512
    if (pString -> nDust < pString -> nLetters)
 
513
        return (FALSE);
 
514
 
 
515
    nBigDust       = 0;
 
516
    nBigDustHeight = pString -> nMiddleHeight / 2;
 
517
 
 
518
    for (i = 0; i < pString -> nDust; i++)
 
519
    {
 
520
        pRoot = & pRoots [pString -> pDustList [i]];
 
521
 
 
522
        if (pRoot -> nHeight >= nBigDustHeight                          &&
 
523
            pRoot -> xColumn                       <= pString -> xRight &&
 
524
            pRoot -> xColumn + pRoot -> nWidth - 1 >= pString -> xLeft)
 
525
        {
 
526
            nBigDust++;
 
527
        }
 
528
    }
 
529
                                                       /* STDG20 */
 
530
    return (pString -> nLetters < 30 && nBigDust > pString -> nLetters ||
 
531
                                        nBigDust > 2 * pString -> nLetters);
 
532
}
 
533
 
 
534
void StringsRemoveTrash (void)
 
535
{
 
536
    STRING *pString;
 
537
    STRING *pNext;
 
538
 
 
539
    pString = pStringsList;
 
540
 
 
541
    while (pString != NULL)
 
542
    {
 
543
        pNext = pString -> pNext;
 
544
 
 
545
        if (StringIsTrash (pString))
 
546
            StringRemove (pString);
 
547
 
 
548
        pString = pNext;
 
549
    }
 
550
}
 
551
 
 
552
void StringsForming (void)
 
553
{
 
554
# ifdef SE_DEBUG
 
555
    if (pCurrentBlock -> pHystogram == NULL ||
 
556
        pCurrentBlock -> nHystColumns == 0)
 
557
    {
 
558
        ErrorInternal ((PSTR)"Empty hystogram");
 
559
    }
 
560
# endif
 
561
 
 
562
    StringPrepare ();
 
563
    StringsFill ();
 
564
 
 
565
    if (bOptionBusinessCardsLayout)
 
566
    {
 
567
        StringFree ();
 
568
        StringsBreakOnVertical ();
 
569
        StringPrepare ();
 
570
 
 
571
# ifdef SE_DEBUG
 
572
        if (SE_DebugGraphicsLevel >= 1)
 
573
            LT_GraphicsStringsOutput ("After breaking on vertical");
 
574
# endif
 
575
    }
 
576
 
 
577
# ifdef SE_DEBUG
 
578
    if (SE_DebugGraphicsLevel >= 2)
 
579
        LT_GraphicsStringsOutput ("Before edit");
 
580
# endif
 
581
 
 
582
    StringsListEdit ();
 
583
 
 
584
# ifdef SE_DEBUG
 
585
    if (SE_DebugGraphicsLevel >= 2)
 
586
        LT_GraphicsStringsOutput ("After edit");
 
587
# endif
 
588
 
 
589
    StringsProcessSpecials ();
 
590
 
 
591
# ifdef SE_DEBUG
 
592
    if (SE_DebugGraphicsLevel >= 2)
 
593
        LT_GraphicsStringsOutput ("After processing specials");
 
594
# endif
 
595
 
 
596
    StringsDustAccount ();
 
597
 
 
598
# ifdef SE_DEBUG
 
599
    if (SE_DebugGraphicsLevel >= 1)
 
600
        LT_GraphicsStringsOutput ("After dust accounting");
 
601
# endif
 
602
 
 
603
    StringFree ();
 
604
 
 
605
    if (! bOptionBusinessCardsLayout)
 
606
    {
 
607
        StringsBreakOnVertical ();
 
608
 
 
609
# ifdef SE_DEBUG
 
610
        if (SE_DebugGraphicsLevel >= 1)
 
611
            LT_GraphicsStringsOutput ("After breaking on vertical");
 
612
# endif
 
613
    }
 
614
 
 
615
    StringsRemoveTrash ();
 
616
 
 
617
# ifdef SE_DEBUG
 
618
    if (SE_DebugGraphicsLevel >= 1)
 
619
        LT_GraphicsStringsOutput ("After removing trash strings");
 
620
 
 
621
    if (SE_DebugGraphicsLevel >= 3)
 
622
    {
 
623
        LT_GraphicsStringsForwardOrderOutput  ("Forward strings order");
 
624
        LT_GraphicsStringsBackwardOrderOutput ("Backward strings order");
 
625
        LT_GraphicsStringsUpOrderOutput       ("Up strings order");
 
626
        LT_GraphicsStringsDownOrderOutput     ("Down strings order");
 
627
    }
 
628
# endif
 
629
 
 
630
        StringsUpdatedByBukvica();
 
631
    StringsListOutput ();
 
632
}