Mercurial > mercurial > hgweb_kaigo.hg.cgi
changeset 4:ff7a3c254956 draft
new: superFC
| author | pyon <pyon@macmini> |
|---|---|
| date | Tue, 15 Jun 2021 06:19:45 +0900 |
| parents | bbeb834023e3 |
| children | 519d6fd0bfd9 |
| files | superFC/Makefile superFC/fc_tmpl.cpp superFC/fc_tmpl.go superFC/fcgo.go superFC/mkgo.pl superFC/sort.list superFC/xdw_api.h superFC/xdwapi.lib superFC/xdwapian.h |
| diffstat | 9 files changed, 3520 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/Makefile Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,3 @@ +all: + perl mkgo.pl fc_tmpl.go fc_tmpl.cpp > fcgo.go + go build fcgo.go
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/fc_tmpl.cpp Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,188 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <io.h> +#include <windows.h> +#include <xdw_api.h> +#include <xdwapian.h> + +#define MAXLINE 12000 +#define BLOCKSZ 128 + +void xdw2txt(const char* xdwfile, const char* txtfile) { + char in_path[_MAX_PATH]; + _fullpath(in_path, xdwfile, _MAX_PATH); + + XDW_DOCUMENT_HANDLE h = NULL; + XDW_OPEN_MODE_EX mode = {sizeof(XDW_OPEN_MODE_EX), XDW_OPEN_READONLY, XDW_AUTH_NODIALOGUE}; + if (XDW_OpenDocumentHandle(in_path, &h, (XDW_OPEN_MODE*)&mode)) { + printf("XDW Error: cannot open %s\n", xdwfile); + return; + } + + int api_result = XDW_GetFullText(h, txtfile, NULL); + if (api_result < 0) { + printf("Error: cannot write text\n"); + return; + } + XDW_CloseDocumentHandle(h, NULL); +} + +void xdwsplit1(const char* xdwfile) { + char in_path[_MAX_PATH]; + _fullpath(in_path, xdwfile, _MAX_PATH); + + XDW_DOCUMENT_HANDLE h = NULL; + XDW_OPEN_MODE_EX mode = {sizeof(XDW_OPEN_MODE_EX), XDW_OPEN_READONLY, XDW_AUTH_NODIALOGUE}; + if (XDW_OpenDocumentHandle(in_path, &h, (XDW_OPEN_MODE*)&mode)) { + printf("Error: cannot open %s\n", xdwfile); + return; + } + + XDW_DOCUMENT_INFO info = {sizeof(XDW_DOCUMENT_INFO), 0, 0, 0}; + XDW_GetDocumentInformation(h, &info); + int nPage = info.nPages; + + char buf[_MAX_PATH]; + for (int i = 1; i <= nPage; i++) { + sprintf(buf, "fctmp_%05d.xdw", i); + _fullpath(in_path, buf, _MAX_PATH); + + int api_result = XDW_GetPage(h, i, in_path, NULL); + if (api_result < 0) { + printf("XDW Error: cannot get page\n"); + return; + } + } + XDW_CloseDocumentHandle(h, NULL); +} + +void xdwmerge(const char* list, const char* output) { + + FILE *fp; + if ((fp = fopen(list, "r")) == NULL) { + fprintf(stderr, "can't open file [%s]\n", list); + exit(1); + } + + char *all_path = (char*)malloc(MAXLINE * sizeof(char) * _MAX_PATH); + if (all_path == NULL) { + fprintf(stderr, "can't allocate memory\n"); + exit(1); + } + + int n = 0; + char *q; + char buf[_MAX_PATH]; + + while (fgets(buf, sizeof buf, fp)) { + if ((q = strchr(buf, '\n')) != NULL) { + *q = '\0'; + } + _fullpath(buf, buf, _MAX_PATH); + strncpy(&all_path[n * _MAX_PATH], buf, _MAX_PATH); + n++; + } + fclose(fp); + + char *blk_path = (char*)malloc(BLOCKSZ * sizeof(char) * _MAX_PATH); + const char **blk_path_addr = (const char**)malloc((n / BLOCKSZ + 1) * sizeof(char*) * _MAX_PATH); + if (blk_path == NULL || blk_path_addr == NULL) { + fprintf(stderr, "can't allocate memory\n"); + exit(1); + } + + // process by block + int api_result; + int bn = 0; + for (int p = 0, m = 0; p < n; p++) { + m = p % BLOCKSZ; + if (m == 0 && p > 0) { + sprintf(buf, "fctmp_b%04d.xdw", ++bn); + _fullpath(buf, buf, _MAX_PATH); + api_result = XDW_MergeXdwFiles(blk_path_addr, BLOCKSZ, buf, NULL); + if (api_result < 0) { + fprintf(stderr, "can't merge [1] (p = %d, m = %d)\n", p, m); + exit(1); + } + } + strncpy(&blk_path[m * _MAX_PATH], &all_path[p * _MAX_PATH], _MAX_PATH); + blk_path_addr[m] = &blk_path[m * _MAX_PATH]; + } + + sprintf(buf, "fctmp_b%04d.xdw", ++bn); + _fullpath(buf, buf, _MAX_PATH); + int mod = n % BLOCKSZ; + if (mod == 0) mod = BLOCKSZ; + api_result = XDW_MergeXdwFiles(blk_path_addr, mod, buf, NULL); + if (api_result < 0) { + fprintf(stderr, "can't merge [2]\n"); + exit(1); + } + + // merge blocks + for (int b = 0; b < bn; b++) { + sprintf(buf, "fctmp_b%04d.xdw", b + 1); + _fullpath(buf, buf, _MAX_PATH); + strncpy(&blk_path[b * _MAX_PATH], buf, _MAX_PATH); + blk_path_addr[b] = &blk_path[b * _MAX_PATH]; + } + _fullpath(buf, output, _MAX_PATH ); + api_result = XDW_MergeXdwFiles(blk_path_addr, bn, buf, NULL); + if (api_result < 0) { + fprintf(stderr, "can't merge [3]\n"); + exit(1); + } + + free(all_path); + free(blk_path); + free(blk_path_addr); +} + +int xdwaddannotation(XDW_DOCUMENT_HANDLE h, int page, int x, int y, char* string, int* sz, int tr) +{ + XDW_ANNOTATION_HANDLE annoation; + int api_result = XDW_AddAnnotation(h, XDW_AID_TEXT, page, x, y, NULL, &annoation, NULL); + if (api_result < 0) { + fprintf(stderr, "can't make annotation\n"); + return -1; + } + + api_result = XDW_SetAnnotationAttribute(h, annoation, XDW_ATN_Text, XDW_ATYPE_STRING, string, 0, NULL); + api_result = XDW_SetAnnotationAttribute(h, annoation, XDW_ATN_FontSize, XDW_ATYPE_INT, (char*)(sz), 0, NULL); + if (tr) { + int color = XDW_COLOR_NONE; + api_result = XDW_SetAnnotationAttribute(h, annoation, XDW_ATN_BackColor, XDW_ATYPE_INT, (char*)(&color), 0, NULL); + } + return 0; +} + +void xdwaddpage(const char* file, int sp) { + XDW_DOCUMENT_HANDLE h = NULL; + XDW_OPEN_MODE_EX mode = {sizeof(XDW_OPEN_MODE_EX), XDW_OPEN_UPDATE, XDW_AUTH_NODIALOGUE}; + int api_result = XDW_OpenDocumentHandle(file, &h, (XDW_OPEN_MODE*)&mode); + if (api_result < 0) { + fprintf(stderr, "can't open file\n"); + exit(1); + } + + XDW_DOCUMENT_INFO info = {sizeof(XDW_DOCUMENT_INFO), 0}; + XDW_GetDocumentInformation(h, &info); + int last_page = info.nPages; + + int sz = 80; + int tr = 1; + char pagenum[12]; + + for (int p = 0; p < last_page; p++) { + sprintf(pagenum, "%05d-%05d", p + sp, last_page); + api_result = xdwaddannotation(h, p + 1, 1769, 5658, pagenum, &sz, tr); + api_result = xdwaddannotation(h, p + 1, 18297, 28326, pagenum, &sz, tr); + if (api_result < 0) break; + } + + if (api_result >= 0) api_result = XDW_SaveDocument(h, NULL); + + XDW_CloseDocumentHandle(h, NULL); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/fc_tmpl.go Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,296 @@ +/* + fcgo.go: Fucho de Go + + Last Change: 2021-06-14 月 16:14:04. +*/ +package main + +/* +#cgo LDFLAGS: -L. -lxdwapi -static +##### C_SOURCE ##### +*/ +import "C" + +import ( + "encoding/csv" + "flag" + "fmt" + "io" + "log" + "os" + "regexp" + "strings" + "time" + + "golang.org/x/text/encoding/japanese" + "golang.org/x/text/transform" +) + +type Data struct { + Hno string + Page string +} + +func (d *Data) ToCsv() string { + s := []string{d.Hno, d.Page} + return strings.Join(s, ",") +} + +var ( + ver = "0.1" + + clean bool + skip bool + debug bool + xdwfile string + + txtfile = "fctmp_txt.txt" + infofile = "fctmp_info.csv" + orderfile = "sort.list" // input + pagefile = "fctmp_page.txt" + output = "output.xdw" +) + +func init() { + /* INITIALIZE FLAGS */ + flag.BoolVar(&clean, "c", false, "clean temporary files & exit") + flag.BoolVar(&skip, "e", false, "use existed files") + flag.BoolVar(&debug, "d", false, "debug mode") + flag.StringVar(&xdwfile, "i", "fc.xdw", "target xdw file") +} + +func main() { + flag.Parse() + + /* PRINT HEADER */ + fmt.Println("===================================================") + fmt.Println(" 普徴のみならず納通なら被保番でソートできるかも... ") + fmt.Printf(" - fcgo [ver %s] -\n", ver) + fmt.Println("===================================================\n") + print_time("now") + fmt.Println("[0] start ...") + + /* CLEAN TEMPORARY DIRECTORY */ + os.Remove(output) + if !skip { + clean_full() + } + if clean { + os.Exit(0) + } + print_time("check done") + + fmt.Println("[1] extract ...") + if !skip { + C.xdw2txt(C.CString(xdwfile), C.CString(txtfile)) + } + print_time("extract done.") + + c := make(chan int) + fmt.Println("[2] split ... (run background)") + go func() { + if !skip { + C.xdwsplit1(C.CString(xdwfile)) + } + print_time("split done.") + c <- 1 + }() + + fmt.Println("[3] analize ...") + data_hash, err := analize(txtfile, infofile) + if err != nil { + log.Fatal(err) + } + print_time("analize done.") + debug_print(debug, fmt.Sprintf("len = %d", len(data_hash))) + + fmt.Println("[4] read order ...") + h_order, n, err := read_order(orderfile) + if err != nil { + log.Fatal(err) + } + print_time("read order done.") + debug_print(debug, fmt.Sprintf("len = %d / %d", len(h_order), n)) + + fmt.Println("[5] make_list ...") + n, err = make_list(h_order, data_hash, pagefile) + if err != nil { + log.Fatal(err) + } + print_time("make list done.") + debug_print(debug, fmt.Sprintf("order = %d", n)) + + <-c + + fmt.Println("[6] merge ...") + clean_mini() + C.xdwmerge(C.CString(pagefile), C.CString(output)) + print_time("merge done.") + clean_mini() + + fmt.Println("[7] page ...") + C.xdwaddpage(C.CString(output), C.int(1)) + print_time("page done.") + + if !debug { + fmt.Println("[8] clean ...") + clean_full() + print_time("clean done.") + } +} + +func analize(txtfile, infofile string) (map[string]Data, error) { + hash := make(map[string]Data) + + c, err := os.ReadFile(txtfile) + if err != nil { + return hash, err + } + r := strings.NewReader(string(c)) + tr := transform.NewReader(r, japanese.ShiftJIS.NewDecoder()) + b, err := io.ReadAll(tr) + if err != nil { + return hash, err + } + + regHno := regexp.MustCompile(`0[1238]0[0-9]{7}`) + + var csv string + + buf := strings.Split(string(b), "期別保険料額") + for p, v := range buf[:len(buf)-1] { + s := zen2han(v) + hno := regHno.FindString(s) + page := fmt.Sprintf("%05d", p + 1) + + data := Data { + Hno: hno, + Page: page, + } + hash[hno] = data + + csv += data.ToCsv() + "\n" + } + + if err := os.WriteFile(infofile, []byte(csv), 0644); err != nil { + return hash, err + } + return hash, nil; +} + +func zen2han(s string) (string) { + s = strings.ReplaceAll(s, "０", "0") + s = strings.ReplaceAll(s, "１", "1") + s = strings.ReplaceAll(s, "２", "2") + s = strings.ReplaceAll(s, "３", "3") + s = strings.ReplaceAll(s, "４", "4") + s = strings.ReplaceAll(s, "５", "5") + s = strings.ReplaceAll(s, "６", "6") + s = strings.ReplaceAll(s, "７", "7") + s = strings.ReplaceAll(s, "８", "8") + return strings.ReplaceAll(s, "９", "9") +} + +func read_order(csvfile string) ([]string, int, error) { + var order []string + + c, err := os.ReadFile(csvfile) + if err != nil { + return order, -1, err + } + r := strings.NewReader(string(c)) + tr := transform.NewReader(r, japanese.ShiftJIS.NewDecoder()) + b, err := io.ReadAll(tr) + if err != nil { + return order, -1, err + } + + n := 0 + cr := csv.NewReader(strings.NewReader(string(b))) + for { + record, err := cr.Read() + if err == io.EOF { + break + } + if err != nil { + return order, n, err + } + + s := zen2han(record[0]) + if strings.HasPrefix(s, "0") { + order = append(order, s) + } + n++ + } + return order, n, nil +} + +func make_list(h_order []string, hash map[string]Data, pagefile string) (int, error) { + var n int + var list []string + done := make(map[string]bool) + + for _, h := range h_order { + if _, ok := done[h]; !ok { + if data, ok := hash[h]; ok { + list = append(list, data.Page) + done[h] = true + n++ + } + } + } + + if err := write_pagefile(pagefile, list); err != nil { + return n, err + } + return n, nil +} + +func write_pagefile(file string, list []string) error { + f, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE, 0755) + if err != nil { + return err + } + for _, p := range list { + fmt.Fprintf(f, "fctmp_%s.xdw\n", p) + } + if err := f.Close(); err != nil { + return err + } + return nil +} + +func print_time(msg string) { + now := time.Now() + fmt.Printf("\t%v # %s\n", now, msg) +} + +func debug_print(debug bool, msg string) { + if debug { + fmt.Printf("\t%s\n", msg) + } +} + +func clean_full() error { + return clean_file("fctmp_") +} + +func clean_mini() error { + return clean_file("fctmp_b") +} + +func clean_file(prefix string) error { + files, err := os.ReadDir(".") + if err != nil { + return err + } + + for _, file := range files { + if strings.HasPrefix(file.Name(), prefix) { + os.Remove(file.Name()) + continue + } + } + return err +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/fcgo.go Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,484 @@ +/* + fcgo.go: Fucho de Go + + Last Change: 2021-06-14 月 16:14:04. +*/ +package main + +/* +#cgo LDFLAGS: -L. -lxdwapi -static +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <io.h> +#include <windows.h> +#include <xdw_api.h> +#include <xdwapian.h> + +#define MAXLINE 12000 +#define BLOCKSZ 128 + +void xdw2txt(const char* xdwfile, const char* txtfile) { + char in_path[_MAX_PATH]; + _fullpath(in_path, xdwfile, _MAX_PATH); + + XDW_DOCUMENT_HANDLE h = NULL; + XDW_OPEN_MODE_EX mode = {sizeof(XDW_OPEN_MODE_EX), XDW_OPEN_READONLY, XDW_AUTH_NODIALOGUE}; + if (XDW_OpenDocumentHandle(in_path, &h, (XDW_OPEN_MODE*)&mode)) { + printf("XDW Error: cannot open %s\n", xdwfile); + return; + } + + int api_result = XDW_GetFullText(h, txtfile, NULL); + if (api_result < 0) { + printf("Error: cannot write text\n"); + return; + } + XDW_CloseDocumentHandle(h, NULL); +} + +void xdwsplit1(const char* xdwfile) { + char in_path[_MAX_PATH]; + _fullpath(in_path, xdwfile, _MAX_PATH); + + XDW_DOCUMENT_HANDLE h = NULL; + XDW_OPEN_MODE_EX mode = {sizeof(XDW_OPEN_MODE_EX), XDW_OPEN_READONLY, XDW_AUTH_NODIALOGUE}; + if (XDW_OpenDocumentHandle(in_path, &h, (XDW_OPEN_MODE*)&mode)) { + printf("Error: cannot open %s\n", xdwfile); + return; + } + + XDW_DOCUMENT_INFO info = {sizeof(XDW_DOCUMENT_INFO), 0, 0, 0}; + XDW_GetDocumentInformation(h, &info); + int nPage = info.nPages; + + char buf[_MAX_PATH]; + for (int i = 1; i <= nPage; i++) { + sprintf(buf, "fctmp_%05d.xdw", i); + _fullpath(in_path, buf, _MAX_PATH); + + int api_result = XDW_GetPage(h, i, in_path, NULL); + if (api_result < 0) { + printf("XDW Error: cannot get page\n"); + return; + } + } + XDW_CloseDocumentHandle(h, NULL); +} + +void xdwmerge(const char* list, const char* output) { + + FILE *fp; + if ((fp = fopen(list, "r")) == NULL) { + fprintf(stderr, "can't open file [%s]\n", list); + exit(1); + } + + char *all_path = (char*)malloc(MAXLINE * sizeof(char) * _MAX_PATH); + if (all_path == NULL) { + fprintf(stderr, "can't allocate memory\n"); + exit(1); + } + + int n = 0; + char *q; + char buf[_MAX_PATH]; + + while (fgets(buf, sizeof buf, fp)) { + if ((q = strchr(buf, '\n')) != NULL) { + *q = '\0'; + } + _fullpath(buf, buf, _MAX_PATH); + strncpy(&all_path[n * _MAX_PATH], buf, _MAX_PATH); + n++; + } + fclose(fp); + + char *blk_path = (char*)malloc(BLOCKSZ * sizeof(char) * _MAX_PATH); + const char **blk_path_addr = (const char**)malloc((n / BLOCKSZ + 1) * sizeof(char*) * _MAX_PATH); + if (blk_path == NULL || blk_path_addr == NULL) { + fprintf(stderr, "can't allocate memory\n"); + exit(1); + } + + // process by block + int api_result; + int bn = 0; + for (int p = 0, m = 0; p < n; p++) { + m = p % BLOCKSZ; + if (m == 0 && p > 0) { + sprintf(buf, "fctmp_b%04d.xdw", ++bn); + _fullpath(buf, buf, _MAX_PATH); + api_result = XDW_MergeXdwFiles(blk_path_addr, BLOCKSZ, buf, NULL); + if (api_result < 0) { + fprintf(stderr, "can't merge [1] (p = %d, m = %d)\n", p, m); + exit(1); + } + } + strncpy(&blk_path[m * _MAX_PATH], &all_path[p * _MAX_PATH], _MAX_PATH); + blk_path_addr[m] = &blk_path[m * _MAX_PATH]; + } + + sprintf(buf, "fctmp_b%04d.xdw", ++bn); + _fullpath(buf, buf, _MAX_PATH); + int mod = n % BLOCKSZ; + if (mod == 0) mod = BLOCKSZ; + api_result = XDW_MergeXdwFiles(blk_path_addr, mod, buf, NULL); + if (api_result < 0) { + fprintf(stderr, "can't merge [2]\n"); + exit(1); + } + + // merge blocks + for (int b = 0; b < bn; b++) { + sprintf(buf, "fctmp_b%04d.xdw", b + 1); + _fullpath(buf, buf, _MAX_PATH); + strncpy(&blk_path[b * _MAX_PATH], buf, _MAX_PATH); + blk_path_addr[b] = &blk_path[b * _MAX_PATH]; + } + _fullpath(buf, output, _MAX_PATH ); + api_result = XDW_MergeXdwFiles(blk_path_addr, bn, buf, NULL); + if (api_result < 0) { + fprintf(stderr, "can't merge [3]\n"); + exit(1); + } + + free(all_path); + free(blk_path); + free(blk_path_addr); +} + +int xdwaddannotation(XDW_DOCUMENT_HANDLE h, int page, int x, int y, char* string, int* sz, int tr) +{ + XDW_ANNOTATION_HANDLE annoation; + int api_result = XDW_AddAnnotation(h, XDW_AID_TEXT, page, x, y, NULL, &annoation, NULL); + if (api_result < 0) { + fprintf(stderr, "can't make annotation\n"); + return -1; + } + + api_result = XDW_SetAnnotationAttribute(h, annoation, XDW_ATN_Text, XDW_ATYPE_STRING, string, 0, NULL); + api_result = XDW_SetAnnotationAttribute(h, annoation, XDW_ATN_FontSize, XDW_ATYPE_INT, (char*)(sz), 0, NULL); + if (tr) { + int color = XDW_COLOR_NONE; + api_result = XDW_SetAnnotationAttribute(h, annoation, XDW_ATN_BackColor, XDW_ATYPE_INT, (char*)(&color), 0, NULL); + } + return 0; +} + +void xdwaddpage(const char* file, int sp) { + XDW_DOCUMENT_HANDLE h = NULL; + XDW_OPEN_MODE_EX mode = {sizeof(XDW_OPEN_MODE_EX), XDW_OPEN_UPDATE, XDW_AUTH_NODIALOGUE}; + int api_result = XDW_OpenDocumentHandle(file, &h, (XDW_OPEN_MODE*)&mode); + if (api_result < 0) { + fprintf(stderr, "can't open file\n"); + exit(1); + } + + XDW_DOCUMENT_INFO info = {sizeof(XDW_DOCUMENT_INFO), 0}; + XDW_GetDocumentInformation(h, &info); + int last_page = info.nPages; + + int sz = 80; + int tr = 1; + char pagenum[12]; + + for (int p = 0; p < last_page; p++) { + sprintf(pagenum, "%05d-%05d", p + sp, last_page); + api_result = xdwaddannotation(h, p + 1, 1769, 5658, pagenum, &sz, tr); + api_result = xdwaddannotation(h, p + 1, 18297, 28326, pagenum, &sz, tr); + if (api_result < 0) break; + } + + if (api_result >= 0) api_result = XDW_SaveDocument(h, NULL); + + XDW_CloseDocumentHandle(h, NULL); +} + + +*/ +import "C" + +import ( + "encoding/csv" + "flag" + "fmt" + "io" + "log" + "os" + "regexp" + "strings" + "time" + + "golang.org/x/text/encoding/japanese" + "golang.org/x/text/transform" +) + +type Data struct { + Hno string + Page string +} + +func (d *Data) ToCsv() string { + s := []string{d.Hno, d.Page} + return strings.Join(s, ",") +} + +var ( + ver = "0.1" + + clean bool + skip bool + debug bool + xdwfile string + + txtfile = "fctmp_txt.txt" + infofile = "fctmp_info.csv" + orderfile = "sort.list" // input + pagefile = "fctmp_page.txt" + output = "output.xdw" +) + +func init() { + /* INITIALIZE FLAGS */ + flag.BoolVar(&clean, "c", false, "clean temporary files & exit") + flag.BoolVar(&skip, "e", false, "use existed files") + flag.BoolVar(&debug, "d", false, "debug mode") + flag.StringVar(&xdwfile, "i", "fc.xdw", "target xdw file") +} + +func main() { + flag.Parse() + + /* PRINT HEADER */ + fmt.Println("===================================================") + fmt.Println(" 普徴のみならず納通なら被保番でソートできるかも... ") + fmt.Printf(" - fcgo [ver %s] -\n", ver) + fmt.Println("===================================================\n") + print_time("now") + fmt.Println("[0] start ...") + + /* CLEAN TEMPORARY DIRECTORY */ + os.Remove(output) + if !skip { + clean_full() + } + if clean { + os.Exit(0) + } + print_time("check done") + + fmt.Println("[1] extract ...") + if !skip { + C.xdw2txt(C.CString(xdwfile), C.CString(txtfile)) + } + print_time("extract done.") + + c := make(chan int) + fmt.Println("[2] split ... (run background)") + go func() { + if !skip { + C.xdwsplit1(C.CString(xdwfile)) + } + print_time("split done.") + c <- 1 + }() + + fmt.Println("[3] analize ...") + data_hash, err := analize(txtfile, infofile) + if err != nil { + log.Fatal(err) + } + print_time("analize done.") + debug_print(debug, fmt.Sprintf("len = %d", len(data_hash))) + + fmt.Println("[4] read order ...") + h_order, n, err := read_order(orderfile) + if err != nil { + log.Fatal(err) + } + print_time("read order done.") + debug_print(debug, fmt.Sprintf("len = %d / %d", len(h_order), n)) + + fmt.Println("[5] make_list ...") + n, err = make_list(h_order, data_hash, pagefile) + if err != nil { + log.Fatal(err) + } + print_time("make list done.") + debug_print(debug, fmt.Sprintf("order = %d", n)) + + <-c + + fmt.Println("[6] merge ...") + clean_mini() + C.xdwmerge(C.CString(pagefile), C.CString(output)) + print_time("merge done.") + clean_mini() + + fmt.Println("[7] page ...") + C.xdwaddpage(C.CString(output), C.int(1)) + print_time("page done.") + + if !debug { + fmt.Println("[8] clean ...") + clean_full() + print_time("clean done.") + } +} + +func analize(txtfile, infofile string) (map[string]Data, error) { + hash := make(map[string]Data) + + c, err := os.ReadFile(txtfile) + if err != nil { + return hash, err + } + r := strings.NewReader(string(c)) + tr := transform.NewReader(r, japanese.ShiftJIS.NewDecoder()) + b, err := io.ReadAll(tr) + if err != nil { + return hash, err + } + + regHno := regexp.MustCompile(`0[1238]0[0-9]{7}`) + + var csv string + + buf := strings.Split(string(b), "期別保険料額") + for p, v := range buf[:len(buf)-1] { + s := zen2han(v) + hno := regHno.FindString(s) + page := fmt.Sprintf("%05d", p + 1) + + data := Data { + Hno: hno, + Page: page, + } + hash[hno] = data + + csv += data.ToCsv() + "\n" + } + + if err := os.WriteFile(infofile, []byte(csv), 0644); err != nil { + return hash, err + } + return hash, nil; +} + +func zen2han(s string) (string) { + s = strings.ReplaceAll(s, "０", "0") + s = strings.ReplaceAll(s, "１", "1") + s = strings.ReplaceAll(s, "２", "2") + s = strings.ReplaceAll(s, "３", "3") + s = strings.ReplaceAll(s, "４", "4") + s = strings.ReplaceAll(s, "５", "5") + s = strings.ReplaceAll(s, "６", "6") + s = strings.ReplaceAll(s, "７", "7") + s = strings.ReplaceAll(s, "８", "8") + return strings.ReplaceAll(s, "９", "9") +} + +func read_order(csvfile string) ([]string, int, error) { + var order []string + + c, err := os.ReadFile(csvfile) + if err != nil { + return order, -1, err + } + r := strings.NewReader(string(c)) + tr := transform.NewReader(r, japanese.ShiftJIS.NewDecoder()) + b, err := io.ReadAll(tr) + if err != nil { + return order, -1, err + } + + n := 0 + cr := csv.NewReader(strings.NewReader(string(b))) + for { + record, err := cr.Read() + if err == io.EOF { + break + } + if err != nil { + return order, n, err + } + + s := zen2han(record[0]) + if strings.HasPrefix(s, "0") { + order = append(order, s) + } + n++ + } + return order, n, nil +} + +func make_list(h_order []string, hash map[string]Data, pagefile string) (int, error) { + var n int + var list []string + done := make(map[string]bool) + + for _, h := range h_order { + if _, ok := done[h]; !ok { + if data, ok := hash[h]; ok { + list = append(list, data.Page) + done[h] = true + n++ + } + } + } + + if err := write_pagefile(pagefile, list); err != nil { + return n, err + } + return n, nil +} + +func write_pagefile(file string, list []string) error { + f, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE, 0755) + if err != nil { + return err + } + for _, p := range list { + fmt.Fprintf(f, "fctmp_%s.xdw\n", p) + } + if err := f.Close(); err != nil { + return err + } + return nil +} + +func print_time(msg string) { + now := time.Now() + fmt.Printf("\t%v # %s\n", now, msg) +} + +func debug_print(debug bool, msg string) { + if debug { + fmt.Printf("\t%s\n", msg) + } +} + +func clean_full() error { + return clean_file("fctmp_") +} + +func clean_mini() error { + return clean_file("fctmp_b") +} + +func clean_file(prefix string) error { + files, err := os.ReadDir(".") + if err != nil { + return err + } + + for _, file := range files { + if strings.HasPrefix(file.Name(), prefix) { + os.Remove(file.Name()) + continue + } + } + return err +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/mkgo.pl Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,13 @@ +use utf8; + +open my $f, '<', $ARGV[1]; +my $cpp = do{local $/; <$f>}; +close $f; + +open $f, '<', $ARGV[0]; +while (<$f>) { + s/##### C_SOURCE #####/$cpp/; + print; +} +close $f; +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/sort.list Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,1282 @@ +OQOOOTWWXT +OROOPRQUPW +OWOOPUSUXX +OWOOSVWTXU +OWOOTPUQTO +OWOOQPWWXU +OWOOROORQO +OWOOTPRQQV +OWOOROOQPT +OWOOSQXROV +OQOOOXTUXR +OWOOORQWVR +OPOOPOPQVO +OWOOROVVWR +OROOPOUSWO +OWOOSWVWPP +OPOOPQQXVX +OQOOOXVXTT +OQOOOVRWSR +OWOOOXTQTT +OWOOOUOSRT +OPOOOVPOQX +OROOPRSVPW +OROOOPSQRQ +OPOOOWWOPO +OPOOOQPWOR +OPOOOUSWPQ +OWOOQTVXWO +OWOOSQPRPS +OWOOSRSSTX +OWOOPVVVOV +OWOOOOSXXR +OWOOOWQTOP +OROOOTUTPQ +OWOORUQURU +OROOORVWRU +OWOOOPWPVO +OQOOOSUURR +OWOOOWVTPP +OQOOOSXQPV +OWOOOWOSPO +OWOOOQXTVO +OROOOTORPO +OWOOPSOTWV +OPOOPPRQUO +OWOOQTVVVW +OWOOSQSOTS +OWOOOSWSSR +OWOOSXXOQO +OWOOOPQTOR +OWOOOOOXUR +OWOOPOTXPX +OWOOSVPVRV +OWOOORWPRW +OWOORSXTUV +OWOOOOSRUT +OQOOOXTSRO +OWOOORUXQT +OWOOORVQPQ +OWOOOSQPRT +OWOOOXPVSW +OWOOPVOOOP +OWOORWQVUX +OPOOOTPOVX +OWOOQQPTRU +OWOOPRPUUX +OWOOQRVURV +OWOOOXSRTU +OWOOQUSUPW +OQOOOSPPQV +OWOOOPPTPT +OWOOOQPUOO +OWOOOQTSXS +OPOOPPWSXP +OWOOOQVUTX +OWOOPXOWRT +OPOOOWPVVU +OWOORTUOSO +OWOOQVSPTO +OWOOOQOROP +OWOOOQPXTQ +OWOOSWUUPO +OWOOOPTSXX +OWOOOPUUQQ +OWOOOPVTTU +OWOOOSXVUW +OWOOOWTQSP +OWOORRPWPP +OWOOSXQQUQ +OWOOOPWWSU +OWOOOXTSXQ +OQOOOUVVRW +OWOOOWXVSR +OWOOPVRQVQ +OROOOXORPP +OWOOOSOSXR +OWOOOPVOTO +OWOOOROTPO +OWOORUTOXO +OWOOOPQTRW +OWOORSXQTV +OWOOOTVUOS +OWOOOUOTQS +OWOOOTPUOU +OWOOOTTQOQ +OWOOOTURSX +OWOOOTUXOO +OWOOOXROUU +OWOOOXWXRX +OWOORQVQQX +OWOORRUVQS +OROOPQXUPV +OWOOOVRRWR +OWOOOXWSPU +OWOOOXWSTX +OWOOPOTTRU +OWOOPPOPWP +OWOOPPXOQQ +OWOOPQXWXR +OWOOPTPVRQ +OWOOOXQUPQ +OWOORSUWPX +OWOOOVSQQR +OWOOOVSRXW +OPOOOUVXWU +OPOOOVUTOO +OPOOPQSOSP +OPOOOVXWVX +OPOOOWQTTP +OPOOOWTPRT +OWOOQQRWUT +OWOOQXSPSQ +OPOOOXPUUU +OPOOOXXRRO +OWOOSRORRO +OPOOOXOQOP +OPOOPOXXRO +OPOOPPSXOX +OWOOPVORSU +OROOOVPVSO +OROOPSUUTP +OWOOQUXRXR +OROOOTWWOX +OROOOUVROP +OROOOWPSUO +OROOOWUPQW +OWOOQVUPRU +OWOOQWWRUR +OROOPSTTWQ +OROOOOXSSP +OROOOUOXTP +OROOOUVVQV +OROOOUXQXO +OROOOWRQVV +OROOOWWXOQ +OWOOPTQSST +OWOOQRWRXO +OWOORORQPS +OROOOTTPSP +OPOOOTTRXQ +OROOOOOTQT +OROOOTOSWS +OROOOTPRRQ +OROOOTQURO +OROOOTSQOO +OWOOQVRUSP +OWOORVPTXV +OROOOQTVSX +OROOPSTSRS +OWOORTXTRW +OWOOSPPVPW +OROOOXOVOQ +OWOORPOQWW +OWOOPUXVUR +OROOOSXQVR +OWOOQQQTPU +OROOORTPWR +OWOOQXSUVR +OWOOQXVTRQ +OROOORVUUU +OROOORVVUR +OROOORWTOU +OWOOQUTSXT +OROOOSPPUV +OROOOSPRST +OWOOSOUPXU +OWOOQSSPTR +OWOOQVVOVW +OROOOORSSR +OROOOOSQPO +OROOOWOVSO +OWOOQUWTQS +OWOOSUQPOO +OWOOSWXSOV +OROOOPVTOX +OROOOPOORQ +OROOOPOTUR +OROOOPRUPX +OROOOTQTTO +OROOPQXWVO +OWOORSWTRU +OWOORVPTTS +OWOOSUOPUU +OROOOQUPTO +OWOOQPSXPQ +OWOOQOOXXV +OROOOPXSWO +OROOOOOSSS +OROOOOPSXP +OROOPPSOVT +OWOORVXTTT +OROOOOUPXP +OROOOOUSRS +OROOOOUTUU +OROOOOVOQR +OROOOOVPWO +OROOOOWRPR +OROOOOXVPX +OROOOPRUSR +OWOOPSVUSU +OWOOQUQWPO +OWOORXSOVS +OROOOTWSRS +OROOPRSQWX +OROOPSSXXR +OROOOWOTWW +OWOORRXRUV +OROOPQXRVS +OROOOXOPRR +OPOOOTURTU +OPOOOTVUUQ +OPOOPPSPWU +OPOOPPSVXW +OPOOOTRORX +OPOOPPQQVQ +OPOOOSUTQO +OPOOOSTTPU +OPOOOORTTS +OPOOOQWRUO +OPOOOROXUX +OPOOORPWXQ +OPOOORQWPR +OPOOORSRVX +OWOOPUOSXX +OWOOQPWRPS +OWOOSQPTRT +OPOOPOTVUS +OROOPPRSOO +OROOPPRTVT +OPOOOSOOQU +OROOPQOTUR +OROOPQQPQS +OROOPQROSO +OROOPQROUU +OROOPQRXUP +OROOPQSOWX +OROOPSSPWV +OROOPSWTOU +OWOOQTSXWP +OROOPPOWVW +OWOOQVRSQO +OWOOSOUOQP +OWOOSXPRQO +OROOPPQXOO +OROOOXRTVS +OROOOXRVWV +OROOOXTOVO +OROOOXTTOO +OROOOXXOVU +OROOPOOSRO +OROOPOPWVX +OROOPOQQUR +OROOPOQVVW +OROOPROSTR +OROOPRQUTO +OWOOPQPTVS +OWOOPQXRXV +OWOOPWPUOV +OWOOQPWTRT +OWOOQQVROT +OWOOQVVPUV +OWOOQWPQOQ +OWOORQSQUQ +OWOORQWWTR +OWOOSRQVWQ +OROOPOTXUR +OROOPOVVWW +OROOPOWOQS +OROOPOXOQO +OWOORTRRVW +OWOOOUSXXU +OWOOOUUOXR +OWOOOXXVTV +OWOOOWPVTO +OWOOOWPXWO +OWOOOWQRSO +OWOOOWQXXS +OWOOOWRWTO +OWOOOWSXRW +OWOOOXTTVR +OWOOPRRVXR +OWOORSXSSR +OWOOSXORWR +OWOOOWTOWO +OPOOOVPWVW +OPOOOURRQW +OPOOOURVXS +OPOOOTQVXQ +OPOOOTUUTW +OPOOOTVWPU +OPOOOTVXTU +OPOOOPUUXX +OPOOOQOWSO +OPOOOQWQUR +OPOOOQWTOU +OPOOOSRVRS +OPOOOSSXWU +OPOOOSTXSO +OWOOPUPOWW +OWOOQUQOOR +OWOORWOOQQ +OWOORXWVQO +OWOOSPXXOT +OPOOOVVRPO +OPOOPQPRQW +OPOOOUTXUV +OPOOOSRSQS +OPOOPOQRTW +OWOOOPOUWR +OPOOOWTQRQ +OPOOOWVSPR +OPOOOWWXSO +OWOOROQOWO +OPOOOPTWVO +OWOOQSWRVO +OPOOOQORUO +OPOOOQPQOO +OPOOOQSWST +OPOOOQTVRU +OPOOOQTVXT +OWOOQTOPQX +OPOOOOOQXU +OPOOOOUTXU +OPOOOOVRVP +OPOOOPQXXT +OPOOOPSRVW +OPOOOPSTWO +OPOOOPVVWS +OPOOOPWUPU +OPOOOQUSOU +OPOOOTOVOU +OPOOPQQQRT +OQOOOPVSQO +OWOOPPTOUO +OWOOPQPRWW +OWOOPQTPTS +OWOORXWUTV +OWOOSRSSWR +OWOOSVTWPR +OPOOOOQPTX +OPOOOOTSQT +OWOOPTROWT +OPOOORQXRV +OPOOOSVPVX +OPOOOUVVOU +OPOOOVSSRT +OPOOOXXQOX +OPOOPOPSWR +OWOOSRSUPO +OPOOOWUTSX +OWOOPRPSOT +OWOOPSXPXR +OWOOQWXVRS +OWOORTRUVO +OWOOOWXWOW +OPOOOOPQTO +OPOOOUOOVW +OPOOOUQWTQ +OPOOOUUUTR +OPOOPPSQVT +OWOOQOQVOP +OWOOQPUSWU +OPOOOVTWTV +OPOOOUXPQP +OPOOOVOTOQ +OPOOOXVRPP +OWOOSWRRVX +OPOOOSTPQT +OPOOOSVSPP +OPOOOSXQSS +OPOOOTPPXQ +OPOOOTTRPV +OPOOPQUUUS +OPOOOTWVUU +OPOOPQVQTR +OWOOPSUQTX +OPOOOPUOSS +OPOOOURPVS +OWOOPPUTUQ +OQOOOOOXVW +OQOOOPRUPP +OQOOOPVRSO +OQOOOQOVPT +OQOOOQPSRU +OQOOOQPTRR +OQOOOQQVOO +OQOOOQTVRR +OQOOOQXSPO +OQOOOQXSQX +OQOOOVXWRR +OQOOOXQPQO +OWOOPSUWRU +OWOOPUWSUT +OWOOPXXRUO +OWOOQSORPO +OWOOSPWXQT +OQOOOQUWVO +OQOOOQVRST +OQOOOROROR +OQOOOROWWT +OQOOOXOSUQ +OQOOOXSPUU +OWOOPRSWSU +OQOOOOPPOX +OQOOOOOUVU +OQOOOOORQR +OQOOOOPRVO +OQOOOORWOQ +OQOOOOSQXX +OQOOOORQVU +OQOOOORUTX +OQOOOOVSSP +OQOOOOWWOS +OQOOOPOOSR +OQOOOQWQSS +OQOOPOTVUP +OWOOSPSQWW +OQOOOPPSPS +OWOOPRUWTV +OQOOOTVTPP +OQOOOTVXOQ +OQOOOVURSU +OQOOOWOUVO +OQOOOWRXXV +OQOOOXOUWR +OWOOPSQQTR +OWOOQUVRSO +OWOOQVVUWO +OQOOOUTTTV +OQOOOUTUXV +OQOOOUUXOP +OQOOOVVRSQ +OQOOOWOXWO +OQOOOWTWOX +OWOOPVWOUP +OWOOQOPSWX +OQOOOVQWRX +OQOOOXVUPO +OQOOOTRUPR +OQOOOVSXSV +OQOOOURSRO +OQOOOWVRSW +OQOOOWRWVR +OWOOQVOORO +OQOOOSURPT +OQOOOSVPRR +OQOOOSXUQS +OQOOOSXVRO +OQOOOTUQQP +OWOOQPWPVX +OWOOQRSUTS +OWOOQSUTPQ +OWOOTOVPQO +OQOOOQSQWP +OQOOORRWTO +OQOOORTSUP +OQOOOXRSST +OWOOSPXPRP +OQOOORUUXV +OQOOORTPSR +OQOOPORPOU +OWOOQUUQSU +OQOOOSPXOX +OQOOOXRTOO +OWOOQTROOS +OQOOORUTWP +OQOOOTPRUO +OQOOOTPVRS +OQOOOTSVTO +OROOOXSQRU +OWOOPWXVWO +OQOOORXTVQ +OQOOOXWTTQ +OWOOPUPXTX +OWOOQTOWTS +OROOPOOQRU +OROOPQUUPW +OWOOOQWOQV +OPOOOOUPXV +OROOOQSSRQ +OWOOSPTPVX +OWOOOWXRXT +OROOOWWURT +OWOOOTXVSV +OROOOUTORP +OPOOPQSQUQ +OROOPOQRQW +OWOOOPVQOR +OWOOSTVWXO +OWOORPRTTS +OWOOROSSSO +OWOOPOVSWQ +OPOOOUPUVW +OWOOQUSSXX +OWOOOPWRQR +OWOOOPXRQO +OQOOOPQORW +OWOOOROWPP +OWOOPUUTPX +OWOOQUOWTO +OROOOVOOXS +OWOOQTTTTS +OPOOPPXQQU +OWOOOVXOXW +OWOOOOVOVO +OWOOPXPSSO +OWOOOQPSTU +OROOOUVSOX +OWOOPTROXR +OWOOQWUUOR +OPOOPQWPSS +OWOORXSRVU +OWOOTOXTPR +OWOOTOXTQP +OWOOQXSTXQ +OWOORPWWXO +OWOOPWQSQT +OWOOQUSVQR +OWOOPOXUTT +OWOOQTPRUQ +OWOOQOQQRO +OQOOOUQPQS +OROOOXQQXQ +OROOOXQROU +OWOOSOURPT +OWOOSWSPSU +OWOOPXWPPX +OWOOQTWUOO +OROOPRRSXT +OWOOPOTVRO +OROOPQUQOO +OWOOPUPTRR +OWOOOQSVWP +OQOOOSSWQV +OWOOPOXSVV +OROOPOPOXV +OWOOPORRPQ +OPOOOUROUX +OPOOOSRPTV +OROOPPRUSW +OWOOSTSVQV +OWOOOSWVQX +OWOOPRTVWW +OWOOQUPXST +OWOOTPPVOS +OWOOOSRUQO +OWOOSWWRWX +OWOOORXXWR +OWOOOSSUUX +OWOOQWRXVR +OWOOOSSVOV +OWOOORXSXT +OWOOOXWRXS +OWOOTOWTRR +OWOOSQTWUV +OWOOORWUWT +OWOOPPPPOQ +OWOOQOVTOX +OWOORVVSOS +OWOOTOOWXR +OWOOSWSVUU +OWOOPVTQOW +OWOOROWTWT +OWOORQQXXT +OWOOQOSQTX +OWOOQSVPXT +OWOOSTQTQO +OWOOQSSSSV +OWOORUVOXR +OWOORUXQQR +OWOOSSQOOP +OWOOPOXSUX +OROOORQSUO +OWOOQSWVOP +OWOOPRPVVS +OWOOQWRWXQ +OWOORSUTQT +OWOORXUTXO +OWOOSXRWOR +OWOOSXUXOO +OWOOOPTOOU +OWOOPTPRRR +OWOOQUSUUX +OWOOROSUPO +OWOOROWVTT +OWOORRUXPO +OWOORSRVXW +OWOOTPPURP +OWOORQTSXW +OWOOOQWSPW +OWOORPVVTS +OWOORTUOXP +OWOOSTQWTU +OWOOPUUUPU +OWOOPVTQVT +OWOOSXQSRQ +OWOOTOSXTR +OWOOTOTPRT +OWOOOPUVTS +OWOOOPVPXO +OWOOQTORVS +OWOORRQVPO +OWOOSSWPRP +OWOOOOWXUS +OWOOQVPSUO +OWOOSSVVPQ +OWOOOPORRO +OWOOPOWRUT +OWOOQXUQSQ +OWOOPVXRXS +OWOOQRQWQP +OWOOTORPXP +OWOOOPRVOS +OWOOOPRVPQ +OWOOPORURO +OWOOPOTVXO +OWOOQRQTVO +OWOOQXWWOU +OWOORQVRRS +OWOOOVUVOU +OWOOQOXQWT +OWOOSSRRVV +OWOOSSRRWT +OWOOTOUSSP +OWOOOPXWXR +OWOOOQOQQO +OWOOOQOXQP +OWOOQQWOSQ +OWOORUWWWO +OWOOPOXTSO +OWOOPVXSUV +OWOOOPWWRW +OWOOOQTRPP +OWOOPQUQWQ +OWOOPSOUOX +OWOOPXWVVP +OWOORRROOW +OWOOTOUVVW +OWOORPTPOV +OWOOQRRXUW +OWOOSOSTWS +OWOOORTVVT +OWOOORUOUQ +OWOOPOXOSR +OPOOOXUUVU +OWOOPPTUQO +OWOOPUUVUS +OWOOOTWSPS +OWOOOTXTSQ +OWOOOTXVUR +OWOOOUOTXP +OWOOPWQTXO +OWOOQOVSWV +OWOOQPXVOP +OWOORSSOQU +OWOORWUURQ +OWOOOTQQUQ +OWOOOTSWUX +OWOOOTTQPO +OWOOOTUTUO +OWOOPOUQOU +OWOOPPPWQO +OWOOQPVUWV +OWOOQUPXUP +OWOOQUTXSO +OWOOQWTVXW +OWOOROQUWS +OWOORVQOPP +OWOOSOUVUT +OWOOSPPXSV +OWOOSPTRSX +OWOOTOTOQO +OWOOOVVWOO +OWOOQRWOVQ +OWOOOVOXRV +OWOOOVPTQU +OWOOOVPUQR +OWOOOVPXPV +OWOOOVQQOS +OWOOQQXVWQ +OWOOQTVVUO +OWOORQOUOV +OWOORTUQVO +OWOORWSUTU +OWOORXQVRO +OWOOSPTRWP +OWOOSSOTPR +OWOOSWSRVT +OWOOSXOSVQ +OWOOOVUTOP +OWOOQXRQSR +OPOOOVSXRP +OWOOPPSUVT +OWOOPURWPP +OWOOQUWSTP +OWOORQRXXP +OWOORVWWPW +OPOOORWTTQ +OPOOOTXPPW +OPOOPOPTPR +OPOOPPRSTV +OPOOPPSOXV +OWOOQPUSOO +OWOOQSTPPV +OPOOOXVXSO +OPOOPPXTWV +OWOOQQTUSV +OWOOQRUVUQ +OWOOQSVWVO +OWOORUWOPS +OWOOTOTTTO +OWOOSWPORP +OROOOVPQOP +OROOOVPQPO +OROOOWPQSO +OWOOQSOSUW +OROOOWQSVT +OROOOXWXXP +OWOOPQWVWP +OWOOPVPXXV +OWOOPXTQOX +OWOOQPUPSP +OWOOSXSUWO +OROOOUOWUQ +OROOOUPXXO +OROOOUQTQO +OROOOUVRXT +OROOOUXUQQ +OROOOVRQRX +OROOPROWWV +OROOPSORWU +OROOPSXSSW +OWOOPSVPSO +OWOOQOXPPO +OWOOQOXVWP +OWOOROROXT +OWOOSRVRWT +OWOOSUPOXO +OWOOPRURXR +OWOOSPVSRO +OWOOQROPRU +OWOOSOQWOW +OROOPROOOR +OWOORPUPOR +OWOORSSWXP +OWOORUXXQS +OWOOSXPXTX +OWOOTOPSPT +OWOOPPXTQX +OWOOPRORQW +OWOOQSWQPR +OWOOQXVURO +OWOOPWRTWW +OWOOQTPPRR +OWOOQXVUSW +OWOOQXVUUS +OWOORRVXQT +OWOORUWSRO +OWOOSWTVSU +OWOOSWXSQR +OROOORPXQV +OROOORQTUV +OROOPQUQUO +OWOOTOXPWP +OROOOQXQVQ +OROOORRQXU +OROOPRVQST +OROOOQVPOT +OWOOPVUUSU +OWOOQTWUUX +OROOOQWQTO +OROOOQWTRT +OWOOQTWUWT +OWOOQPWVRO +OROOOOSTOS +OROOPRTSWO +OROOORRTQO +OROOOSTPVO +OROOOSTRQS +OROOOSUQXO +OROOOSUWOO +OROOOSUWPX +OROOOSVUQX +OROOPRRPOO +OWOOQQVTPW +OWOOQWUXSW +OWOORPUWSV +OWOORQQPPP +OWOORQSUPO +OWOORRVWRU +OWOORWSRQO +OWOOSOVXWQ +OWOOSWTVRW +OWOOQQSPOP +OROOOSQOQR +OROOPRVXOR +OWOOPVWVOR +OWOOQRVPWP +OWOOQVRUOX +OWOORVXSTW +OWOOSWXSTW +OROOORSXOO +OROOORSXPW +OROOPSRVPV +OWOOPROQQO +OWOOQXVUXX +OROOPRSOOX +OWOOPXUOPX +OWOOQPWWOQ +OWOOQRRSQX +OWOORSTVTW +OWOORXRXOU +OWOORRRVXQ +OWOOSWTUPS +OWOOSQQOUO +OWOOSPPQPP +OROOOQOOSU +OWOOPRPOWP +OWOOQSPPPP +OWOOSVVXTU +OROOOROQPP +OWOOPSPSPX +OWOOPVPPQP +OWOOPVSWRO +OWOOQQUOOV +OWOOQTWWUR +OWOOQXVWSQ +OWOOQPRQRP +OWOOQTTQOP +OWOOSQVRQO +OWOORQVRXR +OROOPRQOTV +OWOOPQVUQX +OWOOQPRPXR +OROOOOQWOR +OROOOOQWPP +OROOOORXXO +OROOOOSOOW +OWOOQUPQSS +OROOOOVROX +OROOOPPSWX +OROOORXQSR +OROOPROTOO +OROOPSUXRV +OWOOPQTUTO +OWOOPVWWRT +OWOOQPPWPU +OWOOQSPPOR +OWOORQWRRO +OWOORVRWTX +OWOOSOWORQ +OWOOSVTUOO +OPOOORRTXR +OROOPSPQTO +OWOOPWUQWT +OWOOQQVOQO +OWOOQUXRVV +OWOORPWSTX +OWOOSQPPUO +OWOOSSWTVR +OWOOSTUOQX +OWOOSUUSRP +OWOOSXXSOQ +OWOOTOVOPS +OROOOWQOVU +OROOOWVWUW +OROOOWWOOV +OROOOWWOPT +OROOOWXRPR +OROOPRXRST +OWOOPSQTQO +OWOOPWPQWR +OWOOQPSPRO +OWOOQVUPSS +OWOOQWWSUO +OWOORPRVTX +OWOORSSWRQ +OWOORSVSQS +OWOORUPPOX +OWOORVTUTV +OWOORVWSVW +OWOORWTOTX +OWOOPSPOTQ +OWOOSXXSTR +OWOOTPQQWO +OROOPRPOWT +OWOOQSRQRW +OWOORQPPTW +OWOORURVPR +OWOOSUVSRW +OWOOTPPWPO +OWOOQWWWSR +OWOOPVUQPQ +OPOOOSRPRO +OWOOPXXVWU +OWOORPRXRV +OWOORWXTVV +OPOOORXWUX +OPOOPQSXQO +OWOOPUVPVT +OWOOQQTTWQ +OWOOQSXQUO +OWOOSWRQPQ +OROOPPRWQU +OWOORXPVXQ +OROOPPWWOP +OROOPPXSOX +OWOOQPWUUV +OWOOQSWOQV +OWOOQWPROO +OWOOQWUUVO +OROOPQQUWO +OROOPQRWVQ +OWOOPSTWRO +OWOOPTVSPQ +OWOOSPPRQV +OROOPPTOWO +OROOPPTOXW +OROOPPTUTX +OROOPPVOXO +OROOPRTQVV +OWOOQSXUTP +OWOORTRQXV +OWOOSSQWTO +OWOOSSXQRT +OROOPPQTVX +OWOORRXWSV +OWOORTOXTU +OROOOXRSTO +OROOOXWQRP +OROOOXXTPR +OROOOXXWVS +OROOPOPWXT +OROOPOPXOX +OROOPOTRPX +OWOOPRQUOU +OWOOPWOPTT +OWOOQROSWX +OWOOQRRRTU +OWOOQSRSXP +OWOOQTUVWO +OWOOQWSWUS +OWOOQXSSUO +OWOORSQTSU +OWOORSWPQX +OWOORTRQUQ +OWOORUPTTX +OWOOSPSTPQ +OWOOSWXQST +OWOOSXVWQT +OWOOTOXURV +OWOOTOXUST +OWOOTPQVSR +OWOORPUUPW +OROOPOURSO +OROOPOQORS +OWOOQPSTVQ +OWOOSWUPPS +OWOOOUQXUX +OWOOOURRTR +OWOOOUVPPP +OWOOPOXVVX +OWOOPPPWUQ +OWOOPVPTXW +OWOOPWOXUP +OWOOPWQUPP +OWOOQPQSOT +OWOOQUXPOT +OWOOOWQURR +OWOOOWSVVU +OWOOOWSXQO +OWOOPPQUQP +OWOOPXVOTW +OWOOQWVWVP +OWOOQWWOPO +OWOORUVQUR +OWOOSQRQSS +OWOOSWWRXV +OWOOSPUVPO +OWOOSSROSO +OWOOQUPSRO +OWOOSOPTSQ +OWOOTOUPQR +OPOOOUSWUR +OPOOOTXTOX +OPOOPOUQRO +OPOOPPSSUP +OPOOOOPXUX +OPOOORSRRU +OPOOOSSOWO +OPOOOSTUUS +OPOOPQPXXX +OWOOPQTXWV +OWOOPUTXQO +OWOOQORXQX +OWOOQSWSTO +OWOORUQQVO +OWOOSPWQQS +OWOOSQTPVS +OWOOSXWRSP +OWOOTPSWTP +OPOOOVTUSS +OWOOQTVRVX +OPOOPQUXSO +OWOOQSTUXX +OPOOPORQQQ +OWOOQWTRTU +OWOOTPUSPQ +OPOOOWTWRU +OPOOPPTQWO +OWOOPQQPQO +OWOOPWOTVO +OWOORRWSPV +OWOOQRXTPU +OWOORRQUQP +OWOOSSVSWW +OWOOSTUUQQ +OWOOSWTXSO +OWOOSWVVTV +OPOOOQOWPT +OPOOOQPTUO +OWOORQOOSU +OPOOOQUQUO +OPOOOQUVQS +OPOOPPQWPV +OWOOPSSOPX +OWOOQPTPRV +OWOOSSPXOO +OPOOOOSXOX +OPOOOPSUOQ +OPOOPPOTOS +OWOOPTRQPQ +OWOOQRTRWR +OWOOQXWORQ +OWOORSWWTS +OWOORTRVWT +OWOORVPQXT +OWOORVSOQQ +OWOOTOQTTP +OPOOOTSRQX +OPOOOTSSOO +OPOOOTUUXO +OPOOOURSXQ +OPOOPPOPOT +OWOOQRXSRT +OWOOSVPRRW +OWOOSWTWUO +OPOOOPSVUX +OPOOOPTWUQ +OPOOOPTXOO +OWOORRQQUT +OWOORTVVOT +OWOOSOUOUS +OWOOSQXWRW +OWOOTOVVRP +OPOOPOWSVO +OWOOPSSUPQ +OWOOPXRXUU +OWOOQXTOTO +OPOOPQOSRV +OPOOPQUWTO +OWOOOUTTUX +OWOOSQTQUR +OWOORSWVWP +OPOOPOPVWT +OWOOPWWWOU +OWOOQRXSWU +OWOOQSPROW +OPOOOVVVXT +OPOOOWOSUO +OPOOOWXQUQ +OWOOQOTRWV +OWOOQTPQPS +OWOOQVXWUO +OPOOOXPWQW +OWOOQQXQOO +OPOOOUSRTX +OPOOOVOOXO +OPOOOVOSWO +OPOOPQPOVV +OWOOPQOPUO +OWOOPWTRUO +OWOORXWTTO +OWOOSWRXOT +OWOOQWSVSO +OWOORUUPXS +OPOOPQPVSR +OWOOQUURWU +OWOOQUVTWV +OWOOQUVTXT +OWOOSXPQPT +OPOOOUVUXQ +OPOOOUXQPO +OWOOPWOPOS +OWOORTOVRT +OPOOPPVOXU +OPOOPPWTQP +OWOORRTTXO +OWOORTXQXT +OWOOSSXOTV +OPOOOXWSVS +OPOOPPRUWU +OWOOQSRSWR +OWOOQTOXSR +OWOOQUPOWQ +OWOORORTUV +OPOOORWWOR +OPOOOSSURR +OPOOOSXXST +OPOOOTTQPO +OPOOPPVOQX +OWOOQTUVOS +OPOOOSORXT +OPOOOSPQOO +OPOOORTXWV +OWOOQSXSXO +OWOOQXSQPT +OWOORPWXXW +OPOOOQSXUX +OPOOOQTORT +OWOOPXVWOT +OWOOQVVXXO +OWOOSTPRXU +OPOOOPPSVU +OQOOOPUPRO +OQOOOPVXOO +OQOOOPWSWU +OQOOOPXTPQ +OQOOOQRVSX +OQOOOQXSST +OQOOOXUXTX +OQOOOXXPSP +OWOOOUOUOT +OWOOPUTPQP +OWOOPVTUOV +OWOOPWQVVW +OWOOQURUVO +OWOOQVOSWO +OWOOQXURWQ +OWOOQXWWWP +OWOORPTVSR +OWOORRPQTO +OWOOSRVPPR +OWOOTOTQSO +OQOOOQURUT +OWOOQSPVWQ +OWOOTOOVVO +OWOOPWUSWO +OWOOSPTWXU +OWOORURUOW +OQOOOOQQXU +OWOORSVUXU +OWOOSVVSSP +OQOOOOQSUU +OQOOOOQSWQ +OQOOPOPPQO +OWOOQUTQWQ +OQOOOOSSRS +OQOOOOVSPV +OWOOPWRPPP +OQOOOOVXXX +OQOOOOWORO +OWOOSTTWTT +OQOOOXQTXV +OWOORUPQXO +OWOORSQPOS +OWOOQVSQOU +OWOOROWWRU +OWOORSTOVR +OWOOSOORUW +OQOOOTVWVQ +OQOOOWWXTU +OWOOPWQXPR +OWOOQOVWQV +OWOOQTSTOV +OWOORPWROO +OQOOOVTXPX +OQOOOVVOOW +OQOOOVVOTX +OQOOOVVRTO +OQOOOVVVPV +OQOOOWOOXQ +OQOOOWOPOU +OWOOPSTSOU +OWOOQTWOOU +OWOOQUXRPW +OWOOSOQUPP +OWOOSVQSWQ +OWOOSXXQUV +OQOOOUXRSO +OQOOOVOOOR +OQOOOVXPSO +OQOOOXXQRO +OWOOPSUWWV +OWOOPTOOOO +OWOOPTWRVO +OWOOQPRXQS +OWOOQSXQPO +OWOOROXQQO +OWOORRRPQP +OWOORRVOXV +OWOORSVPTV +OWOORUOXUO +OWOORURPRU +OWOORWUXSQ +OWOOSOQTRO +OWOOSUWOTP +OWOOSXSQTV +OWOOTOPQUP +OQOOOVPVTP +OQOOOVPVWU +OQOOOVTSSV +OWOOPPXRRQ +OWOOQWPWPS +OWOOSWUVXR +OQOOOTVRUW +OQOOOWSUQS +OWOOPSQOVT +OWOOQVVVOP +OWOOROVPXW +OWOORXVRUV +OQOOOWSQQT +OWOORPTWSO +OWOOSTOXSQ +OQOOOURQOP +OWOORPPWST +OWOOSQPOTT +OWOORVTTOX +OWOOSQUPSU +OWOOQWQTQV +OWOORRXRPU +OWOOSSQRWX +OWOOTPTTVQ +OQOOORTUQR +OWOORUTXOQ +OWOOSVSXRO +OWOOSXVTSO +OWOOTOWXSO +OWOOTPRSQP +OQOOOTORSV +OQOOORTVXW +OQOOPOQQXO +OWOOSOVRRW +OWOOSPVSXO +OWOORWTPQP +OQOOOSOWUS +OWOOPSQVPV +OWOOQWQVRO +OWOOSVSXOU +OWOOSXOXXT +OQOOOTRTVT +OWOOQWQVXX +OWOOQXXQVU +OWOOSPQTQW +OQOOOXPOSR +OQOOOTOXOW +OWOOPQPWOX +OWOORPUQPX +OQOOORXSXP +OWOORQRWOO +OWOOSUWSOO +OWOOSWWWVV \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/xdw_api.h Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,1121 @@ +/* File: xdw_api.h +// Copyright(C) 1999-2013 by Fuji Xerox Co., Ltd. All right reserved. +*/ + +#ifndef XDW_API_H +#define XDW_API_H + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#ifndef XDWAPI_DECLARATIONS +#define XDWAPI_DECLARATIONS + +#ifdef _WIN64 +#ifndef XDW_DISABLE_PRAGMA_PACK +#pragma pack(push, xdwapi_enter_parser) +#pragma pack(8) +#endif /* XDW_DISABLE_PRAGMA_PACK */ +#endif /* _WIN64 */ + +#define XDWAPI __stdcall + +#define XDW_GI_VERSION 1 +#define XDW_GI_INSTALLPATH 2 +#define XDW_GI_BINPATH 3 +#define XDW_GI_PLUGINPATH 4 +#define XDW_GI_FOLDERROOTPATH 5 +#define XDW_GI_USERFOLDERPATH 6 +#define XDW_GI_SYSTEMFOLDERPATH 7 +#define XDW_GI_RECEIVEFOLDERPATH 8 +#define XDW_GI_SENDFOLDERPATH 9 +#define XDW_GI_DWINPUTPATH 10 +#define XDW_GI_DWDESKPATH 11 +#define XDW_GI_DWVIEWERPATH 12 +#define XDW_GI_DWVLTPATH 13 +#define XDW_GI_DWDESK_FILENAME_DELIMITER 1001 +#define XDW_GI_DWDESK_FILENAME_DIGITS 1002 + + +#define XDW_PGT_NULL 0 +#define XDW_PGT_FROMIMAGE 1 +#define XDW_PGT_FROMAPPL 2 + +#define XDW_MAXPATH 255 +#define XDW_MAXINPUTIMAGEPATH 127 + +#define XDW_OPEN_READONLY 0 +#define XDW_OPEN_UPDATE 1 + +#define XDW_AUTH_NONE 0 +#define XDW_AUTH_NODIALOGUE 1 +#define XDW_AUTH_CONDITIONAL_DIALOGUE 2 + +#define XDW_PERM_DOC_EDIT 0x02 +#define XDW_PERM_ANNO_EDIT 0x04 +#define XDW_PERM_PRINT 0x08 +#define XDW_PERM_COPY 0x10 + +#define XDW_DT_DOCUMENT 0 +#define XDW_DT_BINDER 1 +#define XDW_DT_CONTAINER 2 + +#define XDW_ROT_0 0 +#define XDW_ROT_90 90 +#define XDW_ROT_180 180 +#define XDW_ROT_270 270 + +#define XDW_CREATE_FITDEF 0 +#define XDW_CREATE_FIT 1 +#define XDW_CREATE_USERDEF 2 +#define XDW_CREATE_USERDEF_FIT 3 +#define XDW_CREATE_FITDEF_DIVIDEBMP 4 + +#define XDW_COMPRESS_NORMAL 0 +#define XDW_COMPRESS_LOSSLESS 1 +#define XDW_COMPRESS_HIGHQUALITY 2 +#define XDW_COMPRESS_HIGHCOMPRESS 3 +#define XDW_COMPRESS_NOCOMPRESS 4 +#define XDW_COMPRESS_JPEG 5 +#define XDW_COMPRESS_PACKBITS 6 +#define XDW_COMPRESS_G4 7 +#define XDW_COMPRESS_MRC_NORMAL 8 +#define XDW_COMPRESS_MRC_HIGHQUALITY 9 +#define XDW_COMPRESS_MRC_HIGHCOMPRESS 10 +#define XDW_COMPRESS_MRC 11 +#define XDW_COMPRESS_JPEG_TTN2 12 + +#define XDW_CONVERT_MRC_ORIGINAL 0 +#define XDW_CONVERT_MRC_OS 1 + +#define XDW_IMAGE_DIB 0 +#define XDW_IMAGE_TIFF 1 +#define XDW_IMAGE_JPEG 2 +#define XDW_IMAGE_PDF 3 + +#define XDW_CREATE_HCENTER 0 +#define XDW_CREATE_LEFT 1 +#define XDW_CREATE_RIGHT 2 + +#define XDW_CREATE_VCENTER 0 +#define XDW_CREATE_TOP 1 +#define XDW_CREATE_BOTTOM 2 + +#define XDW_CREATE_DEFAULT_SIZE 0 +#define XDW_CREATE_A3_SIZE 1 +#define XDW_CREATE_2A0_SIZE 2 + +#define XDW_LINE_NONE 0 +#define XDW_LINE_BEGINNING 1 +#define XDW_LINE_ENDING 2 +#define XDW_LINE_BOTH 3 +#define XDW_LINE_WIDE_POLYLINE 0 +#define XDW_LINE_POLYLINE 1 +#define XDW_LINE_POLYGON 2 + +#define XDW_BORDER_TYPE_SOLID 0 +#define XDW_BORDER_TYPE_DOT 1 +#define XDW_BORDER_TYPE_DASH 2 +#define XDW_BORDER_TYPE_DASHDOT 3 +#define XDW_BORDER_TYPE_DOUBLE 4 + +#define XDW_STAMP_AUTO 0 +#define XDW_STAMP_MANUAL 1 +#define XDW_STAMP_NO_BASISYEAR 0 +#define XDW_STAMP_BASISYEAR 1 +#define XDW_STAMP_DATE_YMD 0 +#define XDW_STAMP_DATE_DMY 1 + +#define XDW_PAGEFORM_HEADER 0 +#define XDW_PAGEFORM_FOOTER 1 +#define XDW_PAGEFORM_TOPIMAGE 2 +#define XDW_PAGEFORM_BOTTOMIMAGE 3 +#define XDW_PAGEFORM_PAGENUMBER 4 + +#define XDW_PAGEFORM_STAY 0 +#define XDW_PAGEFORM_REMOVE 1 + +#define XDW_ALIGN_LEFT 0 +#define XDW_ALIGN_HCENTER 1 +#define XDW_ALIGN_RIGHT 2 +#define XDW_ALIGN_TOP 0 +#define XDW_ALIGN_BOTTOM 1 +#define XDW_ALIGN_VCENTER 2 + +#define XDW_PAGERANGE_ALL 0 +#define XDW_PAGERANGE_SPECIFIED 1 + +#define XDW_CRTP_BEGINNING 1 +#define XDW_CRTP_PRINTING 2 +#define XDW_CRTP_PAGE_CREATING 3 +#define XDW_CRTP_ORIGINAL_APPENDING 4 +#define XDW_CRTP_WRITING 5 +#define XDW_CRTP_ENDING 6 +#define XDW_CRTP_CANCELING 7 +#define XDW_CRTP_FINISHED 8 +#define XDW_CRTP_CANCELED 9 + +#define XDW_AID_FUSEN 32794 +#define XDW_AID_TEXT 32785 +#define XDW_AID_STAMP 32819 +#define XDW_AID_STRAIGHTLINE 32828 +#define XDW_AID_RECTANGLE 32829 +#define XDW_AID_ARC 32830 +#define XDW_AID_POLYGON 32834 +#define XDW_AID_MARKER 32795 +#define XDW_AID_LINK 49199 +#define XDW_AID_PAGEFORM 32814 +#define XDW_AID_OLE 32783 +#define XDW_AID_BITMAP 32831 +#define XDW_AID_RECEIVEDSTAMP 32832 +#define XDW_AID_CUSTOM 32837 +#define XDW_AID_TITLE 32838 +#define XDW_AID_GROUP 32839 + +#define XDW_ATYPE_INT 0 +#define XDW_ATYPE_STRING 1 +#define XDW_ATYPE_DATE 2 +#define XDW_ATYPE_BOOL 3 +#define XDW_ATYPE_OCTS 4 +#define XDW_ATYPE_OTHER 999 + +#define XDW_SUMMARY_INFO 1 +#define XDW_USER_DEF 2 +#define XDW_ANNOTATION 4 + +#define XDW_SIZE_FREE 0 +#define XDW_SIZE_A3_PORTRAIT 1 +#define XDW_SIZE_A3_LANDSCAPE 2 +#define XDW_SIZE_A4_PORTRAIT 3 +#define XDW_SIZE_A4_LANDSCAPE 4 +#define XDW_SIZE_A5_PORTRAIT 5 +#define XDW_SIZE_A5_LANDSCAPE 6 +#define XDW_SIZE_B4_PORTRAIT 7 +#define XDW_SIZE_B4_LANDSCAPE 8 +#define XDW_SIZE_B5_PORTRAIT 9 +#define XDW_SIZE_B5_LANDSCAPE 10 + +#define XDW_BINDER_COLOR_0 0 +#define XDW_BINDER_COLOR_1 1 +#define XDW_BINDER_COLOR_2 2 +#define XDW_BINDER_COLOR_3 3 +#define XDW_BINDER_COLOR_4 4 +#define XDW_BINDER_COLOR_5 5 +#define XDW_BINDER_COLOR_6 6 +#define XDW_BINDER_COLOR_7 7 +#define XDW_BINDER_COLOR_8 8 +#define XDW_BINDER_COLOR_9 9 +#define XDW_BINDER_COLOR_10 10 +#define XDW_BINDER_COLOR_11 11 +#define XDW_BINDER_COLOR_12 12 +#define XDW_BINDER_COLOR_13 13 +#define XDW_BINDER_COLOR_14 14 +#define XDW_BINDER_COLOR_15 15 + +#define XDW_REDUCENOISE_NONE 0 +#define XDW_REDUCENOISE_NORMAL 1 +#define XDW_REDUCENOISE_WEAK 2 +#define XDW_REDUCENOISE_STRONG 3 + +#define XDW_PRIORITY_NONE 0 +#define XDW_PRIORITY_SPEED 1 +#define XDW_PRIORITY_RECOGNITION 2 + +#define XDW_OCR_ENGINE_V4 1 // old name - should be here for compatibility +#define XDW_OCR_ENGINE_DEFAULT 1 +#define XDW_OCR_ENGINE_WRP 2 +#define XDW_OCR_ENGINE_FRE 3 +#define XDW_OCR_ENGINE_FRE_MULTI 4 + +#define XDW_OCR_LANGUAGE_AUTO -1 +#define XDW_OCR_LANGUAGE_JAPANESE 0 +#define XDW_OCR_LANGUAGE_ENGLISH 1 + +#define XDW_OCR_MULTIPLELANGUAGES_ENGLISH 0x02 +#define XDW_OCR_MULTIPLELANGUAGES_FRENCH 0x04 +#define XDW_OCR_MULTIPLELANGUAGES_SIMPLIFIED_CHINESE 0x08 +#define XDW_OCR_MULTIPLELANGUAGES_TRADITIONAL_CHINESE 0x10 +#define XDW_OCR_MULTIPLELANGUAGES_THAI 0x20 +#define XDW_OCR_MULTIPLELANGUAGES_JAPANESE 0x40 +#define XDW_OCR_MULTIPLELANGUAGES_KOREAN 0x80 + +#define XDW_OCR_FORM_AUTO 0 +#define XDW_OCR_FORM_TABLE 1 +#define XDW_OCR_FORM_WRITING 2 + +#define XDW_OCR_COLUMN_AUTO 0 +#define XDW_OCR_COLUMN_HORIZONTAL_SINGLE 1 +#define XDW_OCR_COLUMN_HORIZONTAL_MULTI 2 +#define XDW_OCR_COLUMN_VERTICAL_SINGLE 3 +#define XDW_OCR_COLUMN_VERTICAL_MULTI 4 + +#define XDW_OCR_DOCTYPE_AUTO 0 +#define XDW_OCR_DOCTYPE_HORIZONTAL_SINGLE 1 +#define XDW_OCR_DOCTYPE_PLAINTEXT 2 + +#define XDW_OCR_ENGINE_LEVEL_SPEED 1 +#define XDW_OCR_ENGINE_LEVEL_STANDARD 2 +#define XDW_OCR_ENGINE_LEVEL_ACCURACY 3 + +#define XDW_OCR_MIXEDRATE_JAPANESE 1 +#define XDW_OCR_MIXEDRATE_BALANCED 2 +#define XDW_OCR_MIXEDRATE_ENGLISH 3 + +#define XDW_PROTECT_PSWD 1 +#define XDW_PROTECT_PSWD128 3 +#define XDW_PROTECT_PKI 4 +#define XDW_PROTECT_STAMP 5 +#define XDW_PROTECT_CONTEXT_SERVICE 6 +#define XDW_PROTECT_PSWD256 7 +#define XDW_PROTECT_PKI256 8 + +#define XDW_GPTI_TYPE_EMF 0 +#define XDW_GPTI_TYPE_OCRTEXT 1 + +#define XDW_IMAGE_MONO 0 +#define XDW_IMAGE_COLOR 1 +#define XDW_IMAGE_MONO_HIGHQUALITY 2 + +#define XDW_SIGNATURE_STAMP 100 +#define XDW_SIGNATURE_PKI 102 +#define XDW_SIGNATURE_PKI_SHA256 105 + +#define XDW_SIGNATURE_STAMP_DOC_NONE 0 +#define XDW_SIGNATURE_STAMP_DOC_NOEDIT 1 +#define XDW_SIGNATURE_STAMP_DOC_EDIT 2 +#define XDW_SIGNATURE_STAMP_DOC_BAD 3 + +#define XDW_SIGNATURE_STAMP_STAMP_NONE 0 +#define XDW_SIGNATURE_STAMP_STAMP_TRUSTED 1 +#define XDW_SIGNATURE_STAMP_STAMP_NOTRUST 2 + +#define XDW_SIGNATURE_STAMP_ERROR_OK 0 +#define XDW_SIGNATURE_STAMP_ERROR_NO_OPENING_CASE 1 +#define XDW_SIGNATURE_STAMP_ERROR_NO_SELFSTAMP 2 +#define XDW_SIGNATURE_STAMP_ERROR_OUT_OF_VALIDITY 3 +#define XDW_SIGNATURE_STAMP_ERROR_INVALID_DATA 4 +#define XDW_SIGNATURE_STAMP_ERROR_OUT_OF_MEMORY 100 +#define XDW_SIGNATURE_STAMP_ERROR_UNKNOWN 9999 + +#define XDW_SIGNATURE_PKI_DOC_UNKNOWN 0 +#define XDW_SIGNATURE_PKI_DOC_GOOD 1 +#define XDW_SIGNATURE_PKI_DOC_MODIFIED 2 +#define XDW_SIGNATURE_PKI_DOC_BAD 3 +#define XDW_SIGNATURE_PKI_DOC_GOOD_TRUSTED 4 +#define XDW_SIGNATURE_PKI_DOC_MODIFIED_TRUSTED 5 + +#define XDW_SIGNATURE_PKI_TYPE_LOW 0 +#define XDW_SIGNATURE_PKI_TYPE_MID_LOCAL 1 +#define XDW_SIGNATURE_PKI_TYPE_MID_NETWORK 2 +#define XDW_SIGNATURE_PKI_TYPE_HIGH_LOCAL 3 +#define XDW_SIGNATURE_PKI_TYPE_HIGH_NETWORK 4 + +#define XDW_SIGNATURE_PKI_CERT_UNKNOWN 0 +#define XDW_SIGNATURE_PKI_CERT_OK 1 +#define XDW_SIGNATURE_PKI_CERT_NO_ROOT_CERTIFICATE 2 +#define XDW_SIGNATURE_PKI_CERT_NO_REVOCATION_CHECK 3 +#define XDW_SIGNATURE_PKI_CERT_OUT_OF_VALIDITY 4 +#define XDW_SIGNATURE_PKI_CERT_OUT_OF_VALIDITY_AT_SIGNED_TIME 5 +#define XDW_SIGNATURE_PKI_CERT_REVOKE_CERTIFICATE 6 +#define XDW_SIGNATURE_PKI_CERT_REVOKE_INTERMEDIATE_CERTIFICATE 7 +#define XDW_SIGNATURE_PKI_CERT_INVALID_SIGNATURE 8 +#define XDW_SIGNATURE_PKI_CERT_INVALID_USAGE 9 +#define XDW_SIGNATURE_PKI_CERT_UNDEFINED_ERROR 10 + +#define XDW_SIGNATURE_PKI_ERROR_UNKNOWN 0 +#define XDW_SIGNATURE_PKI_ERROR_OK 1 +#define XDW_SIGNATURE_PKI_ERROR_BAD_PLATFORM 2 +#define XDW_SIGNATURE_PKI_ERROR_WRITE_REG_ERROR 3 +#define XDW_SIGNATURE_PKI_ERROR_BAD_TRUST_LEVEL 4 +#define XDW_SIGNATURE_PKI_ERROR_BAD_REVOKE_CHECK_TYPE 5 +#define XDW_SIGNATURE_PKI_ERROR_BAD_AUTO_IMPORT_CERT_FLAG 6 +#define XDW_SIGNATURE_PKI_ERROR_BAD_SIGN_CONFIG 7 +#define XDW_SIGNATURE_PKI_ERROR_NO_IMAGE_FILE 8 +#define XDW_SIGNATURE_PKI_ERROR_BAD_SIGN_CERT 9 +#define XDW_SIGNATURE_PKI_ERROR_NO_SIGN_CERT 10 +#define XDW_SIGNATURE_PKI_ERROR_NOT_USE_PRIVATE_KEY 11 +#define XDW_SIGNATURE_PKI_ERROR_INVALID 12 +#define XDW_SIGNATURE_PKI_ERROR_BAD_SIGN 13 +#define XDW_SIGNATURE_PKI_ERROR_REVOKE_CHECK_ERROR 14 +#define XDW_SIGNATURE_PKI_ERROR_OUT_OF_VALIDITY 15 +#define XDW_SIGNATURE_PKI_ERROR_NO_CERT 16 +#define XDW_SIGNATURE_PKI_ERROR_FAILURE_IMPOPT_CERT 17 +#define XDW_SIGNATURE_PKI_ERROR_NO_ROOT_CERT 18 +#define XDW_SIGNATURE_PKI_ERROR_BAD_CERT_SIZE 19 +#define XDW_SIGNATURE_PKI_ERROR_BAD_ARG 20 +#define XDW_SIGNATURE_PKI_ERROR_BAD_CERT_FORMAT 21 + +#define XDW_SECURITY_PKI_ERROR_UNKNOWN 0 +#define XDW_SECURITY_PKI_ERROR_OK 1 +#define XDW_SECURITY_PKI_ERROR_BAD_PLATFORM 2 +#define XDW_SECURITY_PKI_ERROR_WRITE_REG_ERROR 3 +#define XDW_SECURITY_PKI_ERROR_BAD_TRUST_LEVEL 4 +#define XDW_SECURITY_PKI_ERROR_BAD_REVOKE_CHECK_TYPE 5 +#define XDW_SECURITY_PKI_ERROR_REVOKED 6 +#define XDW_SECURITY_PKI_ERROR_BAD_SIGN 7 +#define XDW_SECURITY_PKI_ERROR_REVOKE_CHECK_ERROR 8 +#define XDW_SECURITY_PKI_ERROR_OUT_OF_VALIDITY 9 +#define XDW_SECURITY_PKI_ERROR_NO_CERT 10 +#define XDW_SECURITY_PKI_ERROR_FAILURE_IMPORT_CERT 11 +#define XDW_SECURITY_PKI_ERROR_NO_ROOT_CERT 12 +#define XDW_SECURITY_PKI_ERROR_BAD_CERT_FORMAT 13 +#define XDW_SECURITY_PKI_ERROR_BAD_CERT_USAGE 14 +#define XDW_SECURITY_PKI_ERROR_CA_CERT_IS_REVOKED 15 +#define XDW_SECURITY_PKI_ERROR_TOO_MANY_CERT 16 + +#define XDW_IGNORE_CASE 0x02 +#define XDW_IGNORE_WIDTH 0x04 +#define XDW_IGNORE_HIRAKATA 0x08 + +#define XDW_STARCH 1 +#define XDW_STARCH_OFF 0 + +#define XDW_TEXT_UNKNOWN 0 +#define XDW_TEXT_MULTIBYTE 1 +#define XDW_TEXT_UNICODE 2 +#define XDW_TEXT_UNICODE_IFNECESSARY 3 + +#define XDW_HGLOBAL void* + +typedef struct { int dummy; } *XDW_DOCUMENT_HANDLE; +typedef struct { int dummy; } *XDW_CREATE_HANDLE; +typedef struct { int dummy; } *XDW_ANNOTATION_HANDLE; +typedef struct { int dummy; } *XDW_FOUND_HANDLE; + +typedef unsigned short XDW_WCHAR; + +typedef struct tag_XDW_RECT { + long left; + long top; + long right; + long bottom; +} XDW_RECT; + +typedef struct tag_XDW_GPTI_OCRTEXT_UNIT { + const char* lpszText; + XDW_RECT rect; +} XDW_GPTI_OCRTEXT_UNIT; + +typedef struct tag_XDW_GPTI_OCRTEXT { + int nUnitNum; + XDW_GPTI_OCRTEXT_UNIT* pUnits; +} XDW_GPTI_OCRTEXT; + +typedef struct tag_XDW_GPTI_INFO { + int nSize; + int nInfoType; + int nPageWidth; + int nPageHeight; + int nRotateDegree; + int nDataSize; + XDW_HGLOBAL pData; +} XDW_GPTI_INFO; + +typedef struct tag_XDW_DOCUMENT_INFO { + int nSize; + int nPages; + int nVersion; + int nOriginalData; + int nDocType; + int nPermission; + int nShowAnnotations; + int nDocuments; + int nBinderColor; + int nBinderSize; +} XDW_DOCUMENT_INFO; + +typedef struct tag_XDW_PAGE_INFO { + int nSize; + int nWidth; + int nHeight; + int nPageType; + int nHorRes; + int nVerRes; + int nCompressType; + int nAnnotations; +} XDW_PAGE_INFO; + +typedef struct tag_XDW_PAGE_INFO_EX { + int nSize; + int nWidth; + int nHeight; + int nPageType; + int nHorRes; + int nVerRes; + int nCompressType; + int nAnnotations; + int nDegree; + int nOrgWidth; + int nOrgHeight; + int nOrgHorRes; + int nOrgVerRes; + int nImageWidth; + int nImageHeight; +} XDW_PAGE_INFO_EX; + +typedef struct tag_XDW_IMAGE_OPTION { + int nSize; + int nDpi; + int nColor; +} XDW_IMAGE_OPTION; + +typedef struct tag_XDW_OPEN_MODE { + int nSize; + int nOption; +} XDW_OPEN_MODE; + +typedef struct tag_XDW_OPEN_MODE_EX { + int nSize; + int nOption; + int nAuthMode; +} XDW_OPEN_MODE_EX; + +typedef struct tag_XDW_CREATE_OPTION { + int nSize; + int nFitImage; + int nCompress; + int nZoom; + int nWidth; + int nHeight; + int nHorPos; + int nVerPos; +} XDW_CREATE_OPTION; + +typedef struct tag_XDW_CREATE_OPTION_EX { + int nSize; + int nFitImage; + int nCompress; + int nZoom; + int nWidth; + int nHeight; + int nHorPos; + int nVerPos; + int nZoomDetail; +} XDW_CREATE_OPTION_EX; + +typedef struct tag_XDW_CREATE_OPTION_EX2 { + int nSize; + int nFitImage; + int nCompress; + int nZoom; + int nWidth; + int nHeight; + int nHorPos; + int nVerPos; + int nZoomDetail; + int nMaxPaperSize; +} XDW_CREATE_OPTION_EX2; + + +#define XDW_SIZEOF_ORGDATANAME 256 +typedef struct tag_XDW_ORGDATA_INFO { + int nSize; + int nDataSize; + long nDate; + char szName[XDW_SIZEOF_ORGDATANAME]; +} XDW_ORGDATA_INFO; + +typedef struct tag_XDW_ORGDATA_INFOW { + int nSize; + int nDataSize; + long nDate; + XDW_WCHAR szName[XDW_SIZEOF_ORGDATANAME]; +} XDW_ORGDATA_INFOW; + +#define XDW_SIZEOF_LINKROOTFOLDER 256 +typedef struct tag_XDW_LINKROOTFOLDER_INFO { + int nSize; + char szPath[XDW_SIZEOF_LINKROOTFOLDER]; + char szLinkRootFolderName[XDW_SIZEOF_LINKROOTFOLDER]; +} XDW_LINKROOTFOLDER_INFO ; + +typedef struct tag_XDW_LINKROOTFOLDER_INFOW { + int nSize; + XDW_WCHAR wszPath[XDW_SIZEOF_LINKROOTFOLDER]; + XDW_WCHAR wszLinkRootFolderName[XDW_SIZEOF_LINKROOTFOLDER]; +} XDW_LINKROOTFOLDER_INFOW ; + +typedef struct tag_XDW_CREATE_STATUS { + int nSize; + int phase; + int nTotalPage; + int nPage; +} XDW_CREATE_STATUS; + +typedef struct tag_XDW_ANNOTATION_INFO { + int nSize; + XDW_ANNOTATION_HANDLE handle; + int nHorPos; + int nVerPos; + int nWidth; + int nHeight; + int nAnnotationType; + int nChildAnnotations; +} XDW_ANNOTATION_INFO; + + +typedef struct tag_XDW_AA_INITIAL_DATA { + int nSize; + int nAnnotationType; + int nReserved1; + int nReserved2; +} XDW_AA_INITIAL_DATA; + +typedef struct tag_XDW_AA_FUSEN_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nWidth; + int nHeight; +} XDW_AA_FUSEN_INITIAL_DATA; + +typedef struct tag_XDW_AA_STRAIGHTLINE_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nHorVec; + int nVerVec; +} XDW_AA_STRAIGHTLINE_INITIAL_DATA; + +typedef struct tag_XDW_AA_RECT_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nWidth; + int nHeight; +} XDW_AA_RECT_INITIAL_DATA; + +typedef struct tag_XDW_AA_ARC_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nWidth; + int nHeight; +} XDW_AA_ARC_INITIAL_DATA; + +typedef struct tag_XDW_AA_BITMAP_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + char szImagePath[256]; +} XDW_AA_BITMAP_INITIAL_DATA; + +typedef struct tag_XDW_AA_BITMAP_INITIAL_DATAW { + XDW_AA_INITIAL_DATA common; + XDW_WCHAR wszImagePath[256]; +} XDW_AA_BITMAP_INITIAL_DATAW; + +typedef struct tag_XDW_AA_STAMP_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nWidth; +} XDW_AA_STAMP_INITIAL_DATA; + +typedef struct tag_XDW_AA_RECEIVEDSTAMP_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nWidth; +} XDW_AA_RECEIVEDSTAMP_INITIAL_DATA; + +#define XDW_SIZEOF_GUID 36 +typedef struct tag_XDW_AA_CUSTOM_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nWidth; + int nHeight; + char* lpszGuid; + int nCustomDataSize; + unsigned char* pCustomData; +} XDW_AA_CUSTOM_INITIAL_DATA; + +typedef struct tag_XDW_IMAGE_OPTION_EX { + int nSize; + int nDpi; + int nColor; + int nImageType; + void* pDetailOption; +} XDW_IMAGE_OPTION_EX; + +typedef struct tag_XDW_IMAGE_OPTION_TIFF { + int nSize; + int nCompress; + int nEndOfMultiPages; +} XDW_IMAGE_OPTION_TIFF; + +typedef struct tag_XDW_IMAGE_OPTION_JPEG { + int nSize; + int nCompress; +} XDW_IMAGE_OPTION_JPEG; + +typedef struct tag_XDW_IMAGE_OPTION_PDF { + int nSize; + int nCompress; + int nConvertMethod; + int nEndOfMultiPages; +} XDW_IMAGE_OPTION_PDF; + +typedef struct tag_XDW_BINDER_INITIAL_DATA { + int nSize; + int nBinderColor; + int nBinderSize; +} XDW_BINDER_INITIAL_DATA; + +typedef struct tag_XDW_OCR_OPTION_V4 { + int nSize; + int nNoiseReduction; + int nLanguage; + int nInsertSpaceCharacter; + int nJapaneseKnowledgeProcessing; + int nForm; + int nColumn; + int nDisplayProcess; + int nAutoDeskew; +} XDW_OCR_OPTION_V4; + +typedef struct tag_XDW_OCR_OPTION_V5 { + int nSize; + int nNoiseReduction; + int nLanguage; + int nInsertSpaceCharacter; + int nJapaneseKnowledgeProcessing; + int nForm; + int nColumn; + int nDisplayProcess; + int nAutoDeskew; + unsigned int nAreaNum; + XDW_RECT** pAreaRects; +} XDW_OCR_OPTION_V5; + +typedef struct tag_XDW_OCR_OPTION_V5_EX { + int nSize; + int nNoiseReduction; + int nLanguage; + int nInsertSpaceCharacter; + int nJapaneseKnowledgeProcessing; + int nForm; + int nColumn; + int nDisplayProcess; + int nAutoDeskew; + unsigned int nAreaNum; + XDW_RECT** pAreaRects; + int nPriority; +} XDW_OCR_OPTION_V5_EX; + +typedef struct tag_XDW_OCR_OPTION_WRP { + int nSize; + int nNoiseReduction; + int nLanguage; + int nInsertSpaceCharacter; + int nForm; + int nColumn; + int nAutoDeskew; + int nPriority; +} XDW_OCR_OPTION_WRP; + +typedef struct tag_XDW_OCR_OPTION_FRE { + int nSize; + int nNoiseReduction; + int nLanguage; + int nDocumentType; + int nDisplayProcess; + int nAutoDeskew; + unsigned int nAreaNum; + XDW_RECT** pAreaRects; + int nPriority; +} XDW_OCR_OPTION_FRE; + +typedef struct tag_XDW_OCR_OPTION_V7 { + int nSize; + int nNoiseReduction; + int nLanguage; + int nInsertSpaceCharacter; + int nJapaneseKnowledgeProcessing; + int nForm; + int nColumn; + int nDisplayProcess; + int nAutoDeskew; + unsigned int nAreaNum; + XDW_RECT** pAreaRects; + int nPriority; + int nEngineLevel; + int nLanguageMixedRate; + int nHalfSizeChar; +} XDW_OCR_OPTION_V7; + +typedef struct tag_XDW_OCR_OPTION_FRE_V7 { + int nSize; + int nNoiseReduction; + int nLanguage; + int nDocumentType; + int nDisplayProcess; + int nAutoDeskew; + unsigned int nAreaNum; + XDW_RECT** pAreaRects; + int nPriority; + int nEngineLevel; +} XDW_OCR_OPTION_FRE_V7; + +typedef struct tag_XDW_PAGE_COLOR_INFO { + int nSize; + int nColor; + int nImageDepth; +} XDW_PAGE_COLOR_INFO; + +#define XDW_SIZEOF_PSWD 256 +typedef struct tag_XDW_SECURITY_OPTION_PSWD { + int nSize; + int nPermission; + char szOpenPswd[XDW_SIZEOF_PSWD]; + char szFullAccessPswd[XDW_SIZEOF_PSWD]; + char* lpszComment; +} XDW_SECURITY_OPTION_PSWD; + +typedef struct tag_XDW_DER_CERTIFICATE { + void *pCert; + int nCertSize; +} XDW_DER_CERTIFICATE; + +typedef struct tag_XDW_SECURITY_OPTION_PKI { + int nSize; + int nPermission; + XDW_DER_CERTIFICATE* lpxdcCerts; + int nCertsNum; + int nFullAccessCertsNum; + int nErrorStatus; + int nFirstErrorCert; +} XDW_SECURITY_OPTION_PKI; + +typedef struct tag_XDW_PROTECT_OPTION { + int nSize; + int nAuthMode; +} XDW_PROTECT_OPTION; + +typedef struct tag_XDW_RELEASE_PROTECTION_OPTION { + int nSize; + int nAuthMode; +} XDW_RELEASE_PROTECTION_OPTION; + +typedef struct tag_XDW_PROTECTION_INFO { + int nSize; + int nProtectType; + int nPermission; +} XDW_PROTECTION_INFO; + +typedef struct tag_XDW_SIGNATURE_OPTION_V5 { + int nSize; + int nPage; + int nHorPos; + int nVerPos; + int nSignatureType; +} XDW_SIGNATURE_OPTION_V5; + +typedef struct tag_XDW_SIGNATURE_INFO_V5 { + int nSize; + int nSignatureType; + int nPage; + int nHorPos; + int nVerPos; + int nWidth; + int nHeight; + long nSignedTime; +} XDW_SIGNATURE_INFO_V5; + +typedef struct tag_XDW_SIGNATURE_MODULE_STATUS { + int nSize; + int nSignatureType; + int nErrorStatus; +} XDW_SIGNATURE_MODULE_STATUS; + +typedef struct tag_XDW_SIGNATURE_MODULE_OPTION_PKI { + int nSize; + void *pSignerCert; + int nSignerCertSize; +} XDW_SIGNATURE_MODULE_OPTION_PKI; + +#define XDW_SIZEOF_STAMPNAME 256 +#define XDW_SIZEOF_STAMPOWNERNAME 64 +#define XDW_SIZEOF_STAMPREMARKS 1024 +typedef struct tag_XDW_SIGNATURE_STAMP_INFO_V5 { + int nSize; + char lpszStampName[XDW_SIZEOF_STAMPNAME]; + char lpszOwnerName[XDW_SIZEOF_STAMPOWNERNAME]; + long nValidDate; + char lpszRemarks[XDW_SIZEOF_STAMPREMARKS]; + int nDocVerificationStatus; + int nStampVerificationStatus; +} XDW_SIGNATURE_STAMP_INFO_V5; + +#define XDW_SIZEOF_PKIMODULENAME 16 +#define XDW_SIZEOF_PKISUBJECTDN 512 +#define XDW_SIZEOF_PKISUBJECT 256 +#define XDW_SIZEOF_PKIISSUERDN 512 +#define XDW_SIZEOF_PKIISSUER 256 +#define XDW_SIZEOF_PKINOTBEFORE 32 +#define XDW_SIZEOF_PKINOTAFTER 32 +#define XDW_SIZEOF_PKISERIAL 64 +#define XDW_SIZEOF_PKIREMARKS 64 +#define XDW_SIZEOF_PKISIGNEDTIME 32 + +typedef struct tag_XDW_SIGNATURE_PKI_INFO_V5 { + int nSize; + char lpszModule[XDW_SIZEOF_PKIMODULENAME]; + char lpszSubjectDN[XDW_SIZEOF_PKISUBJECTDN]; + char lpszSubject[XDW_SIZEOF_PKISUBJECT]; + char lpszIssuerDN[XDW_SIZEOF_PKIISSUERDN]; + char lpszIssuer[XDW_SIZEOF_PKIISSUER]; + char lpszNotBefore[XDW_SIZEOF_PKINOTBEFORE]; + char lpszNotAfter[XDW_SIZEOF_PKINOTAFTER]; + char lpszSerial[XDW_SIZEOF_PKISERIAL]; + void* pSignerCert; + int nSignerCertSize; + char lpszRemarks[XDW_SIZEOF_PKIREMARKS]; + char lpszSigningTime[XDW_SIZEOF_PKISIGNEDTIME]; + int nDocVerificationStatus; + int nCertVerificationType; + int nCertVerificationStatus; +} XDW_SIGNATURE_PKI_INFO_V5; + +typedef struct tag_XDW_OCR_TEXTINFO { + int nSize; + int nWidth; + int nHeight; + long charset; + char* lpszText; + int nLineRect; + XDW_RECT* pLineRect; +} XDW_OCR_TEXTINFO; + +typedef struct tag_XDW_OCRIMAGE_OPTION { + int nSize; + int nDpi; + int nNoiseReduction; + int nPriority; +} XDW_OCRIMAGE_OPTION; + +typedef struct tag_XDW_FIND_TEXT_OPTION { + int nSize; + int nIgnoreMode; + int nReserved; + int nReserved2; +} XDW_FIND_TEXT_OPTION; + +#define XDW_FOUND_RECT_STATUS_HIT (0) +#define XDW_FOUND_RECT_STATUS_PAGE (1) + +typedef struct tag_XDW_POINT { + int x; + int y; +} XDW_POINT; + + +typedef struct tag_XDW_AA_MARKER_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nCounts; + XDW_POINT* pPoints; +} XDW_AA_MARKER_INITIAL_DATA; + +typedef struct tag_XDW_AA_POLYGON_INITIAL_DATA { + XDW_AA_INITIAL_DATA common; + int nCounts; + XDW_POINT* pPoints; +} XDW_AA_POLYGON_INITIAL_DATA; + +typedef struct XDW_BEGIN_CREATE_OPTION { + int nSize; + BOOL bNoUseSpecifiedApp; +} XDW_BEGIN_CREATE_OPTION; + +#ifdef _WIN64 +#ifndef XDW_DISABLE_PRAGMA_PACK +#pragma pack(pop, xdwapi_enter_parser) +#endif /* XDW_DISABLE_PRAGMA_PACK */ +#endif /* _WIN64 */ + +#endif //XDWAPI_DECLARATIONS + + +int XDWAPI XDW_GetInformation(int nIndex, char* lpszOutput, int nSize, void* reserved); +int XDWAPI XDW_GetInformationW(int nIndex, XDW_WCHAR* lpwszOutput, int nSize, void* reserved); +int XDWAPI XDW_AddSystemFolder(int nIndex, void* reserved ); + +int XDWAPI XDW_MergeXdwFiles(const char** lpszInputPaths, int nFiles, const char* lpszOutputPath, void* reserved ); +int XDWAPI XDW_MergeXdwFilesW(const XDW_WCHAR** lpwszInputPaths, int nFiles, const XDW_WCHAR* lpwszOutputPath, void* reserved ); +int XDWAPI XDW_OpenDocumentHandle(const char* lpszFilePath, XDW_DOCUMENT_HANDLE* pHandle, XDW_OPEN_MODE* pOpenMode); +int XDWAPI XDW_OpenDocumentHandleW(const XDW_WCHAR* lpwszFilePath, XDW_DOCUMENT_HANDLE* pHandle, XDW_OPEN_MODE* pOpenMode); +int XDWAPI XDW_CloseDocumentHandle(XDW_DOCUMENT_HANDLE handle, void* reserved ); +int XDWAPI XDW_GetDocumentInformation(XDW_DOCUMENT_HANDLE handle, XDW_DOCUMENT_INFO* pDocumentInfo); +int XDWAPI XDW_GetPageInformation(XDW_DOCUMENT_HANDLE handle, int nPage, XDW_PAGE_INFO* pPageInfo); +int XDWAPI XDW_GetPageImage(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_GetPageImageW(XDW_DOCUMENT_HANDLE handle, int nPage, const XDW_WCHAR* lpwszOutputPath, void* reserved); +int XDWAPI XDW_GetPageText(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszOutputPath, void* reserved ); +int XDWAPI XDW_ConvertPageToImageFile(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszOutputPath, XDW_IMAGE_OPTION* pImageOption); +int XDWAPI XDW_ConvertPageToImageFileW(XDW_DOCUMENT_HANDLE handle, int nPage, const XDW_WCHAR* lpwszOutputPath, XDW_IMAGE_OPTION* pImageOption); +int XDWAPI XDW_GetPage(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_GetPageW(XDW_DOCUMENT_HANDLE handle, int nPage, const XDW_WCHAR* lpwszOutputPath, void* reserved); +int XDWAPI XDW_DeletePage(XDW_DOCUMENT_HANDLE handle, int nPage, void* reserved); +int XDWAPI XDW_RotatePage(XDW_DOCUMENT_HANDLE handle, int nPage, int nDegree, void* reserved); +int XDWAPI XDW_SaveDocument(XDW_DOCUMENT_HANDLE handle, void* reserved); +int XDWAPI XDW_CreateXdwFromImageFile(const char* lpszInputPath, const char* lpszOutputPath, XDW_CREATE_OPTION* pOption); +int XDWAPI XDW_CreateXdwFromImageFileW(const XDW_WCHAR* lpwszInputPath, const XDW_WCHAR* lpwszOutputPath, XDW_CREATE_OPTION* pOption); + +int XDWAPI XDW_GetOriginalDataInformation(XDW_DOCUMENT_HANDLE handle, int nOriginalData, XDW_ORGDATA_INFO* pOriginalDataInfo, void* reserved); +int XDWAPI XDW_GetOriginalData(XDW_DOCUMENT_HANDLE handle, int nOriginalData, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_GetOriginalDataW(XDW_DOCUMENT_HANDLE handle, int nOriginalData, const XDW_WCHAR* lpwszOutputPath, void* reserved); +int XDWAPI XDW_InsertOriginalData(XDW_DOCUMENT_HANDLE handle, int nOriginalData, const char* lpszInputPath, void* reserved); +int XDWAPI XDW_DeleteOriginalData(XDW_DOCUMENT_HANDLE handle, int nOriginalData, void* reserved); + +int XDWAPI XDW_BeginCreationFromAppFile(const char* lpszInputPath, const char* lpszOutputPath, BOOL bWithOriginal, XDW_CREATE_HANDLE* handle, void* pCreateOption); +int XDWAPI XDW_BeginCreationFromAppFileW(const XDW_WCHAR* lpszInputPath, const XDW_WCHAR* lpszOutputPath, BOOL bWithOriginal, XDW_CREATE_HANDLE* handle, void* pCreateOption); +int XDWAPI XDW_EndCreationFromAppFile(XDW_CREATE_HANDLE handle, void* reserved); +int XDWAPI XDW_GetStatusCreationFromAppFile(XDW_CREATE_HANDLE handle, XDW_CREATE_STATUS* pStatus); +int XDWAPI XDW_CancelCreationFromAppFile(XDW_CREATE_HANDLE handle, void* reserved); + +int XDWAPI XDW_GetUserAttribute(XDW_DOCUMENT_HANDLE handle, const char* lpszAttributeName, char* pAttributeValue, int nDataSize, void *reserved); +int XDWAPI XDW_SetUserAttribute(XDW_DOCUMENT_HANDLE handle, const char* lpszAttributeName, char* pAttributeValue, int nDataSize, void *reserved); + +int XDWAPI XDW_GetAnnotationInformation(XDW_DOCUMENT_HANDLE hDocument, int nPage, XDW_ANNOTATION_HANDLE hAnnotation,int nIndex, XDW_ANNOTATION_INFO* pAnnotationInfo, void* reserved); +int XDWAPI XDW_GetAnnotationAttribute(XDW_ANNOTATION_HANDLE handle, const char* lpszAttributeName, char* pAttribute, int nDataSize, void* reserved); + +int XDWAPI XDW_AddAnnotation(XDW_DOCUMENT_HANDLE handle, int hAnnotationType, int nPage, int nHorPos, int nVerPos, XDW_AA_INITIAL_DATA *pInitialData, XDW_ANNOTATION_HANDLE* phNewAnnotation, void* reserved); +int XDWAPI XDW_RemoveAnnotation(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hRemoveAnnotation, void* reserved); +int XDWAPI XDW_SetAnnotationAttribute(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, const char* lpszAttributeName, int nAttributeType, char* pAttributeValue, int nReserved, void* pReserved); +int XDWAPI XDW_SetAnnotationSize(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, int nWidth, int nHeight, void* reserved); +int XDWAPI XDW_SetAnnotationPosition(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, int nHorPos, int nVerPos, void* reserved); +int XDWAPI XDW_CreateSfxDocument(const char* lpszInputPath, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_CreateSfxDocumentW(const XDW_WCHAR* lpwszInputPath, const XDW_WCHAR* lpwszOutputPath, void* reserved); +int XDWAPI XDW_ExtractFromSfxDocument(const char* lpszInputPath, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_ExtractFromSfxDocumentW(const XDW_WCHAR* lpwszInputPath, const XDW_WCHAR* lpwszOutputPath, void* reserved); + +int XDWAPI XDW_ConvertPageToImageHandle(XDW_DOCUMENT_HANDLE handle, int nPage, XDW_HGLOBAL* phDIB, XDW_IMAGE_OPTION* pImageOption); +int XDWAPI XDW_GetThumbnailImageHandle(XDW_DOCUMENT_HANDLE handle, int nPage, XDW_HGLOBAL* phDIB, void* reserved); + +int XDWAPI XDW_GetPageTextToMemory(XDW_DOCUMENT_HANDLE handle, int nPage, char* lpszValue, int nDataSize, void* reserved); +int XDWAPI XDW_GetFullText(XDW_DOCUMENT_HANDLE handle, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_GetPageUserAttribute(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszAttributeName, char* pAttributeValue, int nDataSize, void *reserved); +int XDWAPI XDW_SetPageUserAttribute(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszAttributeName, char* pAttributeValue, int nDataSize, void *reserved); + +int XDWAPI XDW_ReducePageNoise(XDW_DOCUMENT_HANDLE handle, int nPage, int nLevel, void* reserved); +int XDWAPI XDW_ShowOrHideAnnotations(XDW_DOCUMENT_HANDLE handle, int nShowAnnotations, void* reserved); +int XDWAPI XDW_GetCompressedPageImage(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_GetCompressedPageImageW(XDW_DOCUMENT_HANDLE handle, int nPage, const XDW_WCHAR* lpwszOutputPath, void* reserved); +int XDWAPI XDW_InsertDocument(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszInputPath, void* reserved); +int XDWAPI XDW_InsertDocumentW(XDW_DOCUMENT_HANDLE handle, int nPage, const XDW_WCHAR* lpwszInputPath, void* reserved); +int XDWAPI XDW_ApplyOcr(XDW_DOCUMENT_HANDLE handle, int nPage, int nOcrEngine, void* pOption, void* reserved); +int XDWAPI XDW_RotatePageAuto(XDW_DOCUMENT_HANDLE handle, int nPage, void* reserved); +int XDWAPI XDW_CreateBinder(const char* lpszOutputPath, XDW_BINDER_INITIAL_DATA* pInitialData, void* reserved); +int XDWAPI XDW_CreateBinderW(const XDW_WCHAR* lpwszOutputPath, XDW_BINDER_INITIAL_DATA* pInitialData, void* reserved); +int XDWAPI XDW_InsertDocumentToBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, const char* lpszInputPath, void* reserved); + +int XDWAPI XDW_GetDocumentFromBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_GetDocumentFromBinderW(XDW_DOCUMENT_HANDLE handle, int nPosition, const XDW_WCHAR* lpwszOutputPath, void* reserved); +int XDWAPI XDW_DeleteDocumentInBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, void* reserved); +int XDWAPI XDW_GetDocumentNameInBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, char* lpszDocName, int nDocNameSize, void* reserved); +int XDWAPI XDW_SetDocumentNameInBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, char* lpszDocName, void* reserved); +int XDWAPI XDW_GetDocumentInformationInBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, XDW_DOCUMENT_INFO* pDocumentInfo, void* reserved); +int XDWAPI XDW_Finalize(void* reserved); +int XDWAPI XDW_GetPageColorInformation(XDW_DOCUMENT_HANDLE handle, int nPage, XDW_PAGE_COLOR_INFO* pColorInfo, void* reserved); +int XDWAPI XDW_OptimizeDocument(const char* lpszInputPath, const char* lpszOutputPath, void* reserved); +int XDWAPI XDW_OptimizeDocumentW(const XDW_WCHAR* lpwszInputPath, const XDW_WCHAR* lpwszOutputPath, void* reserved); +int XDWAPI XDW_ProtectDocument(const char* lpszInputPath, const char* lpszOutputPath, int nProtectType, void* pModuleOption, void* pProtectOption); +int XDWAPI XDW_ProtectDocumentW(const XDW_WCHAR* lpwszInputPath, const XDW_WCHAR* lpwszOutputPath, int nProtectType, void* pModuleOption, void* pProtectOption); + +int XDWAPI XDW_CreateXdwFromImageFileAndInsertDocument(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszInputPath, XDW_CREATE_OPTION* pOption, void* reserved); +int XDWAPI XDW_CreateXdwFromImageFileAndInsertDocumentW(XDW_DOCUMENT_HANDLE handle, int nPage, const XDW_WCHAR* lpwszInputPath, XDW_CREATE_OPTION* pOption, void* reserved); +int XDWAPI XDW_GetDocumentAttributeNumber(XDW_DOCUMENT_HANDLE handle, void* reserved); +int XDWAPI XDW_GetDocumentAttributeByName(XDW_DOCUMENT_HANDLE handle, const char* lpszAttributeName, int* nAttributeType, char* pAttributeValue, int nDataSize, void* reserved); +int XDWAPI XDW_GetDocumentAttributeByOrder(XDW_DOCUMENT_HANDLE handle, int nOrder, char* lpszAttributeName, int* nAttributeType, char* pAttributeValue, int nDataSize, void* reserved); +int XDWAPI XDW_SetDocumentAttribute(XDW_DOCUMENT_HANDLE handle, const char* lpszAttributeName, int nAttributeType, char* pAttributeValue, void* reserved); +int XDWAPI XDW_SucceedAttribute(XDW_DOCUMENT_HANDLE handle, const char* lpszFilePath, int nDocument, int nSuccession, void* reserved); +int XDWAPI XDW_SucceedAttributeW(XDW_DOCUMENT_HANDLE handle, const XDW_WCHAR* lpwszFilePath, int nDocument, int nSuccession, void* reserved); +int XDWAPI XDW_GetPageFormAttribute(XDW_DOCUMENT_HANDLE handle, int nPageForm, const char* lpszAttributeName, char* pAttributeValue, int nDataSize, void* reserved); +int XDWAPI XDW_SetPageFormAttribute(XDW_DOCUMENT_HANDLE handle, int nPageForm, const char* lpszAttributeName, int nAttributeType, char* pAttributeValue, int nReserved, void* pReserved); +int XDWAPI XDW_UpdatePageForm(XDW_DOCUMENT_HANDLE handle, int nOtherPageForm, void* reserved); +int XDWAPI XDW_RemovePageForm(XDW_DOCUMENT_HANDLE handle, int nOtherPageForm, void* reserved); +int XDWAPI XDW_GetLinkRootFolderInformation(int nOrder, XDW_LINKROOTFOLDER_INFO* pLinkRootFolderInfo, void* reserved); +int XDWAPI XDW_GetLinkRootFolderInformationW(int nOrder, XDW_LINKROOTFOLDER_INFOW* pLinkRootFolderInfo, void* reserved); +int XDWAPI XDW_GetLinkRootFolderNumber(void* reserved); +int XDWAPI XDW_GetLinkRootFolderNumberW(void* reserved); +int XDWAPI XDW_GetPageTextInformation(XDW_DOCUMENT_HANDLE handle, int nPage, void* pInfo, void* reserved); +int XDWAPI XDW_GetDocumentSignatureNumber(XDW_DOCUMENT_HANDLE handle, void* reserved); +int XDWAPI XDW_AddAnnotationOnParentAnnotation(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, int hAnnotationType, int nHorPos, int nVerPos, XDW_AA_INITIAL_DATA *pInitialData, XDW_ANNOTATION_HANDLE* phNewAnnotation, void* reserved); +int XDWAPI XDW_SignDocument(const char* lpszInputPath, const char* lpszOutputPath, void* pOption, void* pModuleOption, void* pReserved, void* pModuleStatus); +int XDWAPI XDW_SignDocumentW(const XDW_WCHAR* lpwszInputPath, const XDW_WCHAR* lpwszOutputPath, void* pOption, void* pModuleOption, void* pReserved, void* pModuleStatus); +int XDWAPI XDW_GetSignatureInformation(XDW_DOCUMENT_HANDLE handle, int nSignature, void* pInfo, void* pModuleInfo, void* pReserved, void* pModuleStatus); +int XDWAPI XDW_UpdateSignatureStatus(XDW_DOCUMENT_HANDLE handle, int nSignature, void* pModuleOption, void* pReserved, void* pModuleStatus); + +int XDWAPI XDW_GetOcrImage(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszOutputPath, void* pImageOption, void* reserved); +int XDWAPI XDW_GetOcrImageW(XDW_DOCUMENT_HANDLE handle, int nPage, const XDW_WCHAR* lpwszOutputPath, void* pImageOption, void* reserved); +int XDWAPI XDW_SetOcrData(XDW_DOCUMENT_HANDLE handle, int nPage, XDW_OCR_TEXTINFO* pData, void* reserved); + +int XDWAPI XDW_GetDocumentAttributeNumberInBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, void* reserved); +int XDWAPI XDW_GetDocumentAttributeByNameInBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, const char* lpszAttributeName, int* nAttributeType, char* pAttributeValue, int nDataSize, void* reserved); +int XDWAPI XDW_GetDocumentAttributeByOrderInBinder(XDW_DOCUMENT_HANDLE handle, int nPosition, int nOrder, char* lpszAttributeName, int* nAttributeType, char* pAttributeValue, int nDataSize, void* reserved); + +int XDWAPI XDW_GetTMInfo(XDW_DOCUMENT_HANDLE handle, void* pTMInfo, int nTMInfoSize, void* reserved); +int XDWAPI XDW_SetTMInfo(XDW_DOCUMENT_HANDLE handle, const void* pTMInfo, int nTMInfoSize, void* reserved); + +int XDWAPI XDW_CreateXdwFromImagePdfFile(const char* lpszInputPath, const char* lpszOutputPath, void* reserved); + +int XDWAPI XDW_FindTextInPage(XDW_DOCUMENT_HANDLE handle, int nPage, const char* lpszText, XDW_FIND_TEXT_OPTION* pOption, XDW_FOUND_HANDLE* pFoundHandle, void* reserved); +int XDWAPI XDW_FindNext(XDW_FOUND_HANDLE* pFoundHandle, void* reserved); +int XDWAPI XDW_GetNumberOfRectsInFoundObject(XDW_FOUND_HANDLE foundHandle, void* reserved); +int XDWAPI XDW_GetRectInFoundObject(XDW_FOUND_HANDLE foundHandle, int nRect, XDW_RECT* pRect, int* pnStatus, void* reserved); +int XDWAPI XDW_CloseFoundHandle(XDW_FOUND_HANDLE foundHandle); + +int XDWAPI XDW_GetAnnotationUserAttribute(XDW_ANNOTATION_HANDLE hAnnotation, const char* lpszAttributeName, char* pAttributeValue, int nDataSize, void *reserved); +int XDWAPI XDW_SetAnnotationUserAttribute(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, const char* lpszAttributeName, char* pAttributeValue, int nDataSize, void *reserved); + +int XDWAPI XDW_StarchAnnotation(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, int nStarch, void* reserved); + +int XDWAPI XDW_ReleaseProtectionOfDocument(const char* lpszInputPath, const char* lpszOutputPath, void* pOption); +int XDWAPI XDW_ReleaseProtectionOfDocumentW(const XDW_WCHAR* lpwszInputPath, const XDW_WCHAR* lpwszOutputPath, void* pOption); +int XDWAPI XDW_GetProtectionInformation(const char* lpszInputPath, XDW_PROTECTION_INFO* pProtectionInfo, void* reserved); +int XDWAPI XDW_GetProtectionInformationW(const XDW_WCHAR* lpwszInputPath, XDW_PROTECTION_INFO* pProtectionInfo, void* reserved); + +int XDWAPI XDW_GetAnnotationCustomAttributeByName(XDW_ANNOTATION_HANDLE hAnnotation, XDW_WCHAR* lpszAttributeName, int* pnAttributeType, char* pAttributeValue, int nDataSize, void* reserved); +int XDWAPI XDW_GetAnnotationCustomAttributeByOrder(XDW_ANNOTATION_HANDLE hAnnotation, int nOrder, XDW_WCHAR* lpszAttributeName, int* pnAttributeType, char* pAttributeValue, int nDataSize, void* reserved); +int XDWAPI XDW_GetAnnotationCustomAttributeNumber(XDW_ANNOTATION_HANDLE hAnnotation, void* reserved); +int XDWAPI XDW_SetAnnotationCustomAttribute(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, XDW_WCHAR* lpszAttributeName, int nAttributeType, char* pAttributeValue, void* reserved); + +int XDWAPI XDW_GetPageTextToMemoryW(XDW_DOCUMENT_HANDLE handle, int nPage, XDW_WCHAR* pValue, int nBufferLength, void* reserved); +int XDWAPI XDW_GetFullTextW(XDW_DOCUMENT_HANDLE handle, const XDW_WCHAR* pOutputPath, void* reserved); +int XDWAPI XDW_GetAnnotationAttributeW(XDW_ANNOTATION_HANDLE handle, const char* lpszAttributeName, void* pAttributeValue, int nDataSize, int* pnTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_SetAnnotationAttributeW(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, const char* lpszAttributeName, int nAttributeType, void* pAttributeValue, int nTextType, unsigned int codepage, int nReserved, void* pReserved); +int XDWAPI XDW_GetDocumentAttributeByNameW(XDW_DOCUMENT_HANDLE handle, const XDW_WCHAR* pAttributeName, int* pnAttributeType, void* pAttributeValue, int nDataSize, int* pnTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_GetDocumentAttributeByOrderW(XDW_DOCUMENT_HANDLE handle, int nOrder, XDW_WCHAR* pAttributeName, int* pnAttributeType, void* pAttributeValue, int nDataSize, int* pnTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_GetDocumentAttributeByNameInBinderW(XDW_DOCUMENT_HANDLE handle, int nPosition, const XDW_WCHAR* pAttributeName, int* pnAttributeType, void* pAttributeValue, int nDataSize, int* pnTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_GetDocumentAttributeByOrderInBinderW(XDW_DOCUMENT_HANDLE handle, int nPosition, int nOrder, XDW_WCHAR* pAttributeName, int* pnAttributeType, void* pAttributeValue, int nDataSize, int* pnTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_SetDocumentAttributeW(XDW_DOCUMENT_HANDLE handle, const XDW_WCHAR* pAttributeName, int nAttributeType, void* pAttributeValue, int nTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_GetDocumentNameInBinderW(XDW_DOCUMENT_HANDLE handle, int nPosition, XDW_WCHAR* pDocName, int nBufferLength, int* pnTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_SetDocumentNameInBinderW(XDW_DOCUMENT_HANDLE handle, int nPosition, const XDW_WCHAR* pDocName, int nTextType, unsigned int codepage, void* reserved); +int XDWAPI XDW_GetOriginalDataInformationW(XDW_DOCUMENT_HANDLE handle, int nOriginalData, XDW_ORGDATA_INFOW* pOriginalDataInfoW, int* pnTextType, unsigned int codepage, void* reserved); + +int XDWAPI XDW_AddAnnotationFromAnnFile(XDW_DOCUMENT_HANDLE handle, const char* lpszAnnFilePath, int nIndex, int nPage, XDW_ANNOTATION_HANDLE hAnnotation, int nHorPos, int nVerPos, XDW_ANNOTATION_HANDLE* phNewAnnotation, void* reserved); +int XDWAPI XDW_AddAnnotationFromAnnFileW(XDW_DOCUMENT_HANDLE handle, const XDW_WCHAR* lpwszAnnFilePath, int nIndex, int nPage, XDW_ANNOTATION_HANDLE hAnnotation, int nHorPos, int nVerPos, XDW_ANNOTATION_HANDLE* phNewAnnotation, void* reserved); +int XDWAPI XDW_GroupAnnotations(XDW_DOCUMENT_HANDLE handle, int nPage, XDW_ANNOTATION_HANDLE hAnnotation, int* pnAnntationIndexes, int nAnnotationNum, XDW_ANNOTATION_HANDLE* phNewAnnotation, void* reserved); +int XDWAPI XDW_UnGroupAnnotation(XDW_DOCUMENT_HANDLE handle, XDW_ANNOTATION_HANDLE hAnnotation, void* reserved); + +/* error code */ +#ifndef XDWAPI_E_DECLARATIONS +#define XDWAPI_E_DECLARATIONS + +#define XDW_E_NOT_INSTALLED ((int)0x80040001) +#define XDW_E_INFO_NOT_FOUND ((int)0x80040002) +#define XDW_E_INSUFFICIENT_BUFFER ((int)0x8007007A) +#define XDW_E_FILE_NOT_FOUND ((int)0x80070002) +#define XDW_E_FILE_EXISTS ((int)0x80070050) +#define XDW_E_ACCESSDENIED ((int)0x80070005) +#define XDW_E_BAD_FORMAT ((int)0x8007000B) +#define XDW_E_OUTOFMEMORY ((int)0x8007000E) +#define XDW_E_WRITE_FAULT ((int)0x8007001D) +#define XDW_E_SHARING_VIOLATION ((int)0x80070020) +#define XDW_E_DISK_FULL ((int)0x80070027) +#define XDW_E_INVALIDARG ((int)0x80070057) +#define XDW_E_INVALID_NAME ((int)0x8007007B) +#define XDW_E_INVALID_ACCESS ((int)0x80040003) +#define XDW_E_INVALID_OPERATION ((int)0x80040004) +#define XDW_E_NEWFORMAT ((int)0x800E0004) +#define XDW_E_BAD_NETPATH ((int)0x800E0005) +#define XDW_E_APPLICATION_FAILED ((int)0x80001156) +#define XDW_E_SIGNATURE_MODULE ((int)0x800E0010) +#define XDW_E_PROTECT_MODULE ((int)0x800E0012) +#define XDW_E_UNEXPECTED ((int)0x8000FFFF) +#define XDW_E_CANCELED ((int)0x80040005) +#define XDW_E_ANNOTATION_NOT_ACCEPTED ((int)0x80040006) + +#endif //XDWAPI_E_DECLARATIONS + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif /* __cplusplus */ + +#endif /* XDW_API_H */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/superFC/xdwapian.h Tue Jun 15 06:19:45 2021 +0900 @@ -0,0 +1,133 @@ +/* File: xdwapian.h +// Copyright(C) 1999-2002 by Fuji Xerox Co., Ltd. All right reserved. +*/ + +#ifndef __XDWAPIAN_H__ +#define __XDWAPIAN_H__ 1 + +#define XDW_ATN_Text "%Text" +#define XDW_ATN_FontName "%FontName" +#define XDW_ATN_FontStyle "%FontStyle" +#define XDW_ATN_FontSize "%FontSize" +#define XDW_ATN_ForeColor "%ForeColor" +#define XDW_ATN_FontPitchAndFamily "%FontPitchAndFamily" +#define XDW_ATN_FontCharSet "%FontCharSet" +#define XDW_ATN_BackColor "%BackColor" +#define XDW_ATN_Caption "%Caption" +#define XDW_ATN_Url "%Url" +#define XDW_ATN_XdwPath "%XdwPath" +#define XDW_ATN_ShowIcon "%ShowIcon" +#define XDW_ATN_LinkType "%LinkType" +#define XDW_ATN_XdwPage "%XdwPage" +#define XDW_ATN_Tooltip "%Tooltip" +#define XDW_ATN_Tooltip_String "%TooltipString" +#define XDW_ATN_XdwPath_Relative "%XdwPathRelative" +#define XDW_ATN_XdwLink "%XdwLink" +#define XDW_ATN_LinkAtn_Title "%LinkAtnTitle" +#define XDW_ATN_OtherFilePath "%OtherFilePath" +#define XDW_ATN_OtherFilePath_Relative "%OtherFilePathRelative" +#define XDW_ATN_MailAddress "%MailAddress" +#define XDW_ATN_BorderStyle "%BorderStyle" +#define XDW_ATN_BorderWidth "%BorderWidth" +#define XDW_ATN_BorderColor "%BorderColor" +#define XDW_ATN_BorderTransparent "%BorderTransparent" +#define XDW_ATN_BorderType "%BorderType" +#define XDW_ATN_FillStyle "%FillStyle" +#define XDW_ATN_FillColor "%FillColor" +#define XDW_ATN_FillTransparent "%FillTransparent" +#define XDW_ATN_ArrowheadType "%ArrowheadType" +#define XDW_ATN_ArrowheadStyle "%ArrowheadStyle" +#define XDW_ATN_WordWrap "%WordWrap" +#define XDW_ATN_TextDirection "%TextDirection" +#define XDW_ATN_TextOrientation "%TextOrientation" +#define XDW_ATN_LineSpace "%LineSpace" +#define XDW_ATN_AutoResize "%AutoResize" +#define XDW_ATN_Invisible "%Invisible" +#define XDW_ATN_PageFrom "%PageFrom" +#define XDW_ATN_XdwNameInXbd "%XdwNameInXbd" +#define XDW_ATN_TopField "%TopField" +#define XDW_ATN_BottomField "%BottomField" +#define XDW_ATN_DateStyle "%DateStyle" +#define XDW_ATN_YearField "%YearField" +#define XDW_ATN_MonthField "%MonthField" +#define XDW_ATN_DayField "%DayField" +#define XDW_ATN_BasisYearStyle "%BasisYearStyle" +#define XDW_ATN_BasisYear "%BasisYear" +#define XDW_ATN_DateField_FirstChar "%DateFieldFirstChar" +#define XDW_ATN_Alignment "%Alignment" +#define XDW_ATN_LeftRightMargin "%LeftRightMargin" +#define XDW_ATN_TopBottomMargin "%TopBottomMargin" +#define XDW_ATN_VerPosition "%VerPosition" +#define XDW_ATN_StartingNumber "%StartingNumber" +#define XDW_ATN_Digit "%Digit" +#define XDW_ATN_PageRange "%PageRange" +#define XDW_ATN_BeginningPage "%BeginningPage" +#define XDW_ATN_EndingPage "%EndingPage" +#define XDW_ATN_Zoom "%Zoom" +#define XDW_ATN_ImageFile "%ImageFile" +#define XDW_ATN_Points "%Points" +#define XDW_ATN_DateFormat "%DateFormat" +#define XDW_ATN_DateOrder "%DateOrder" +#define XDW_ATN_TextSpacing "%Spacing" +#define XDW_ATN_TextTopMargin "%TopMargin" +#define XDW_ATN_TextLeftMargin "%LeftMargin" +#define XDW_ATN_TextBottomMargin "%BottomMargin" +#define XDW_ATN_TextRightMargin "%RightMargin" +#define XDW_ATN_TextAutoResizeHeight "%AutoResizeHeight" +#define XDW_ATN_GUID "%CustomAnnGuid" +#define XDW_ATN_CustomData "%CustomAnnCustomData" + +#define XDW_PROP_TITLE "%Title" +#define XDW_PROP_SUBJECT "%Subject" +#define XDW_PROP_AUTHOR "%Author" +#define XDW_PROP_KEYWORDS "%Keywords" +#define XDW_PROP_COMMENTS "%Comments" + +#define XDW_PROPW_TITLE L"%Title" +#define XDW_PROPW_SUBJECT L"%Subject" +#define XDW_PROPW_AUTHOR L"%Author" +#define XDW_PROPW_KEYWORDS L"%Keywords" +#define XDW_PROPW_COMMENTS L"%Comments" + +#define XDW_COLOR_NONE 0x010101 +#define XDW_COLOR_BLACK 0x000000 +#define XDW_COLOR_MAROON 0x000080 +#define XDW_COLOR_GREEN 0x008000 +#define XDW_COLOR_OLIVE 0x008080 +#define XDW_COLOR_NAVY 0x800000 +#define XDW_COLOR_PURPLE 0x800080 +#define XDW_COLOR_TEAL 0x808000 +#define XDW_COLOR_GRAY 0x808080 +#define XDW_COLOR_SILVER 0xC0C0C0 +#define XDW_COLOR_RED 0x0000FF +#define XDW_COLOR_LIME 0x00FF00 +#define XDW_COLOR_YELLOW 0x00FFFF +#define XDW_COLOR_BLUE 0xFF0000 +#define XDW_COLOR_FUCHIA 0xFF00FF +#define XDW_COLOR_AQUA 0xFFFF00 +#define XDW_COLOR_WHITE 0xFFFFFF +#define XDW_COLOR_FUSEN_RED 0xFFC2FF +#define XDW_COLOR_FUSEN_BLUE 0xFFBF9D +#define XDW_COLOR_FUSEN_YELLOW 0x64FFFF +#define XDW_COLOR_FUSEN_LIME 0xC2FF9D +#define XDW_COLOR_FUSEN_PALE_RED 0xE1D7FF +#define XDW_COLOR_FUSEN_PALE_BLUE 0xFAE1C8 +#define XDW_COLOR_FUSEN_PALE_YELLOW 0xC3FAFF +#define XDW_COLOR_FUSEN_PALE_LIME 0xD2FACD + +#define XDW_FS_ITALIC_FLAG 1 +#define XDW_FS_BOLD_FLAG 2 +#define XDW_FS_UNDERLINE_FLAG 4 +#define XDW_FS_STRIKEOUT_FLAG 8 + +#define XDW_LT_LINK_TO_ME 0 +#define XDW_LT_LINK_TO_XDW 1 +#define XDW_LT_LINK_TO_URL 2 +#define XDW_LT_LINK_TO_OTHERFILE 3 +#define XDW_LT_LINK_TO_MAILADDR 4 + +#define XDW_PF_XDW 0 +#define XDW_PF_XBD 1 +#define XDW_PF_XDW_IN_XBD 2 + +#endif //__XDWAPIAN_H__