1 #include "studiox_includes.h"
2
3 UCHAR filling_string[] = "000";
4
5 #define GX_RESOURCE_STANDALONE_HEADER_SIZE 8 /* 2 bytes type, 2 bytes version, 4 bytes count. */
6
7 ///////////////////////////////////////////////////////////////////////////////
binary_resource_gen(studiox_project * proj,BOOL file_format)8 binary_resource_gen::binary_resource_gen(studiox_project *proj, BOOL file_format)
9 : resource_gen(proj)
10 {
11 m_num_displays = proj->mHeader.num_displays;
12 m_project = proj;
13
14 m_written_size = 0;
15 m_written_start_address = 0;
16 m_file_format = file_format;
17 m_srec_address = proj->mHeader.memory_offset;
18 m_srec_data_size = 0;
19 memset(m_srec_data, 0, SREC_MAX_DATA_SIZE);
20 m_srec_record_count = 0;
21 m_output_resource_id = 0;
22
23 if (GetCmdInfo()->IsNoGui())
24 {
25 m_big_endian = GetCmdInfo()->IsBigEndian();
26 }
27 else
28 {
29 m_big_endian = m_project->mHeader.big_endian;
30 }
31 }
32
33
34 ///////////////////////////////////////////////////////////////////////////////
~binary_resource_gen()35 binary_resource_gen::~binary_resource_gen()
36 {
37 }
38
39 ////////////////////////////////////////////////////////////////////////////////////////////////
InitRotatedPixelmaps()40 void binary_resource_gen::InitRotatedPixelmaps()
41 {
42 for (int theme = 0; theme < m_project->mDisplays[m_display].num_themes; theme++)
43 {
44 m_rotated_pixelmaps[theme].RemoveAll();
45
46 for (int index = 0; index < m_pixelmap_table_size; index++)
47 {
48 m_rotated_pixelmaps[theme].Add(GX_NULL);
49 }
50 }
51 }
52
53 ////////////////////////////////////////////////////////////////////////////////////////////////
DestroyRotatedPixelmaps()54 void binary_resource_gen::DestroyRotatedPixelmaps()
55 {
56 GX_PIXELMAP *map;
57
58 for (int theme = 0; theme < m_project->mDisplays[m_display].num_themes; theme++)
59 {
60 for (int index = 0; index < m_pixelmap_table_size; index++)
61 {
62 map = m_rotated_pixelmaps[theme].GetAt(index);
63 if (map)
64 {
65 pixelmap_destroy(map);
66 }
67 }
68 }
69 }
70
71 ///////////////////////////////////////////////////////////////////////////////
InitResource()72 void binary_resource_gen::InitResource()
73 {
74 m_project->CopyDictionary(m_display, RES_TYPE_PIXELMAP, &m_pixelmap_dictionary);
75 m_project->SortResDictionary(RES_TYPE_PIXELMAP, &m_pixelmap_dictionary);
76
77 CalculateTableSizes();
78
79 InitOptimizedFonts();
80 InitRotatedPixelmaps();
81 InitFontSizeStorage(m_display);
82
83 if (m_file_format == BINARY_FILE_FORMAT_BIN_STANDALONE)
84 {
85 MakeFileDictionary();
86 }
87
88 }
89
90 ///////////////////////////////////////////////////////////////////////////////
DestroyResource()91 void binary_resource_gen::DestroyResource()
92 {
93 DestroyOptimizedFonts();
94 DestroyRotatedPixelmaps();
95 DeleteFontSizeStorage(m_display);
96
97 CloseOutputFiles();
98
99 if (m_file_format == BINARY_FILE_FORMAT_BIN_STANDALONE)
100 {
101 DestroyFileDictionay();
102 }
103 }
104
105 ///////////////////////////////////////////////////////////////////////////////
GenerateBinaryFile(int display)106 BOOL binary_resource_gen::GenerateBinaryFile(int display)
107 {
108 m_display = display;
109 m_color_table_size = m_font_table_size = m_pixelmap_table_size = 0;
110
111 GotoProjectDirectory();
112
113 // for now just use project name for output name
114 CCommandInfo *pCmdInfo = GetCmdInfo();
115 CString res_file_name;
116
117 CCommandInfo *pCmd = GetCmdInfo();
118 BOOL gen_res_header;
119
120 if (pCmd->IsNoGui())
121 {
122 gen_res_header = pCmd->GenResHeader();
123 }
124 else
125 {
126 gen_res_header = m_project->mHeader.gen_res_header;
127 }
128
129 InitResource();
130
131 if (gen_res_header)
132 {
133 res_file_name = m_project->mHeader.header_path;
134 if (!res_file_name.IsEmpty())
135 {
136 if (res_file_name.GetAt(res_file_name.GetLength() - 1) != '\\')
137 {
138 res_file_name += "\\";
139 }
140 }
141 res_file_name += GetResourceFileName() + _T(".h");
142
143 if (m_outfile)
144 {
145 delete m_outfile;
146 }
147
148 m_outfile = new CFile();
149
150 /* Generate head file. */
151 if (!m_outfile->Open(res_file_name, CFile::modeCreate | CFile::modeWrite))
152 {
153 CString msg;
154 msg.Format(_T("Could not open output file:\n%s\nPlease check resource file path."), res_file_name);
155
156 ErrorMsg(msg);
157
158 delete m_outfile;
159 DestroyResource();
160 return FALSE;
161 }
162 GenerateResourceHeader();
163 m_outfile->Close();
164 }
165
166 // Generate binary resource data
167 res_file_name = m_project->mHeader.resource_path;
168 if (!res_file_name.IsEmpty())
169 {
170 if (res_file_name.GetAt(res_file_name.GetLength() - 1) != '\\')
171 {
172 res_file_name += "\\";
173 }
174 }
175
176 res_file_name += GetResourceFileName();
177
178 switch (m_file_format)
179 {
180 case BINARY_FILE_FORMAT_BIN:
181 case BINARY_FILE_FORMAT_BIN_STANDALONE:
182 res_file_name += _T(".bin");
183 break;
184
185 case BINARY_FILE_FORMAT_SREC:
186 res_file_name += _T(".srec");
187 break;
188 }
189
190 if (m_outfile)
191 {
192 delete m_outfile;
193 m_outfile = NULL;
194 }
195
196 m_outfile = new CFile();
197
198 if (!m_outfile->Open(res_file_name, CFile::modeCreate | CFile::modeWrite))
199 {
200 CString msg;
201 msg.Format(_T("Could not open output file:\n%s\nPlease check resource file path."), res_file_name);
202
203 ErrorMsg(msg);
204 delete m_outfile;
205 DestroyResource();
206 return FALSE;
207 }
208
209 outfile_list.Add(m_outfile);
210
211 if (m_file_format == BINARY_FILE_FORMAT_SREC)
212 {
213 m_written_size = m_srec_address;
214 m_written_start_address = m_srec_address;
215 WriteSRecordHeader();
216 }
217 else
218 {
219 m_written_size = 0;
220 m_written_start_address = 0;
221 }
222
223 if (pCmdInfo->IsXmlMode())
224 {
225 BOOL enabled;
226 m_warn_on_error = TRUE;
227
228 WriteStandaloneResHeader();
229
230 for (int theme = 0; theme < m_project->mDisplays[m_display].num_themes; theme++)
231 {
232 theme_info* current = &m_project->mDisplays[m_display].themes[theme];
233
234 if (pCmd->IsNoGui())
235 {
236 enabled = pCmd->IsThemeEnabled(current->theme_name);
237 }
238 else
239 {
240 enabled = current->enabled;
241 }
242
243 if (!enabled)
244 {
245 continue;
246 }
247
248 for (int font_id = 0; font_id < m_project->CountResources(m_display, RES_TYPE_FONT); font_id++)
249 {
250 res_info* info = m_project->FindResource(m_display, theme, RES_TYPE_FONT, font_id);
251
252 if (IsResEnabled(info))
253 {
254 WriteFontBlock(info, 0, theme);
255 }
256 }
257
258 for (int pixelmap_id = 1; pixelmap_id < m_pixelmap_dictionary.GetCount(); pixelmap_id++)
259 {
260 res_info *info = m_project->FindResource(m_display, theme, RES_TYPE_PIXELMAP, m_pixelmap_dictionary.GetAt(pixelmap_id));
261
262 if (IsResEnabled(info) && info->GetPixelmapFrameCount())
263 {
264 for (int frame_id = 0; frame_id < info->GetPixelmapFrameCount(); frame_id++)
265 {
266 WritePixelmapBlock(info, 0, 0, theme, frame_id);
267 }
268 }
269 }
270 }
271 }
272 else
273 {
274 GenerateBinaryData();
275 }
276
277 if (m_file_format == BINARY_FILE_FORMAT_SREC)
278 {
279 if (m_srec_data_size)
280 {
281 WriteOneSRecord();
282 }
283
284 WriteSRecordEnd();
285 }
286
287 DestroyResource();
288
289 return TRUE;
290 }
291
292 ///////////////////////////////////////////////////////////////////////////////
GenerateBinaryData()293 BOOL binary_resource_gen::GenerateBinaryData()
294 {
295 WriteResourceHeader();
296
297 BOOL enabled;
298 CCommandInfo *pCmd = GetCmdInfo();
299
300 for (int theme = 0; theme < m_project->mDisplays[m_display].num_themes; theme++)
301 {
302 theme_info *current = &m_project->mDisplays[m_display].themes[theme];
303
304 if (pCmd->IsNoGui())
305 {
306 enabled = pCmd->IsThemeEnabled(current->theme_name);
307 }
308 else
309 {
310 enabled = current->enabled;
311 }
312
313 if (enabled)
314 {
315 WriteThemeBlock(theme);
316 }
317 }
318
319 if (GetEnabledLanguageCount())
320 {
321 WriteStringBlock();
322 }
323 return TRUE;
324 }
325
326 ///////////////////////////////////////////////////////////////////////////////
WriteResourceHeader()327 void binary_resource_gen::WriteResourceHeader()
328 {
329 //write magic number
330 GX_RESOURCE_HEADER header;
331 ULONG theme_data_size = GetThemeDataSize(-1);
332 ULONG string_data_size = GetStringDataSize();
333
334 header.gx_resource_header_magic_number = GX_MAGIC_NUMBER;
335 header.gx_resource_header_version = m_project->mHeader.guix_version;
336 header.gx_resource_header_theme_count = GetEnabledThemeCount();
337 header.gx_resource_header_language_count = GetEnabledLanguageCount();
338 header.gx_resource_header_theme_data_size = theme_data_size;
339 header.gx_resource_header_string_data_size = string_data_size;
340 header.gx_resource_header_data_size = theme_data_size + string_data_size;
341
342 UCHAR header_array[GX_RESOURCE_HEADER_SIZE];
343 int index = 0;
344 SHORT s;
345 LONG l;
346
347 s = SwapUshort(header.gx_resource_header_magic_number);
348 memcpy_s(header_array, GX_RESOURCE_HEADER_SIZE, &s, sizeof(USHORT));
349 index += sizeof(USHORT);
350
351 if (index < GX_RESOURCE_HEADER_SIZE)
352 {
353 s = SwapUshort(header.gx_resource_header_version);
354 memcpy_s(header_array + index, GX_RESOURCE_HEADER_SIZE - index, &s, sizeof(USHORT));
355 index += sizeof(USHORT);
356 }
357
358 if (index < GX_RESOURCE_HEADER_SIZE)
359 {
360 s = SwapUshort(header.gx_resource_header_theme_count);
361 memcpy_s(header_array + index, GX_RESOURCE_HEADER_SIZE - index, &s, sizeof(USHORT));
362 index += sizeof(USHORT);
363 }
364
365 if (index < GX_RESOURCE_HEADER_SIZE)
366 {
367 s = SwapUshort(header.gx_resource_header_language_count);
368 memcpy_s(header_array + index, GX_RESOURCE_HEADER_SIZE - index, &s, sizeof(USHORT));
369 index += sizeof(USHORT);
370 }
371
372 if (index < GX_RESOURCE_HEADER_SIZE)
373 {
374 l = SwapUint(header.gx_resource_header_theme_data_size);
375 memcpy_s(header_array + index, GX_RESOURCE_HEADER_SIZE - index, &l, sizeof(LONG));
376 index += sizeof(LONG);
377 }
378
379 if (index < GX_RESOURCE_HEADER_SIZE)
380 {
381 l = SwapUint(header.gx_resource_header_string_data_size);
382 memcpy_s(header_array + index, GX_RESOURCE_HEADER_SIZE - index, &l, sizeof(LONG));
383 index += sizeof(LONG);
384 }
385
386 if (index < GX_RESOURCE_HEADER_SIZE)
387 {
388 l = SwapUint(header.gx_resource_header_data_size);
389 memcpy_s(header_array + index, GX_RESOURCE_HEADER_SIZE - index, &l, sizeof(LONG));
390 index += sizeof(LONG);
391 }
392
393 WriteDataOut(header_array, GX_RESOURCE_HEADER_SIZE);
394 }
395
396 ///////////////////////////////////////////////////////////////////////////////
WriteThemeHeader(GX_THEME_HEADER * header)397 void binary_resource_gen::WriteThemeHeader(GX_THEME_HEADER* header)
398 {
399 UCHAR header_array[GX_THEME_HEADER_SIZE];
400 int index = 0;
401 SHORT s;
402 LONG l;
403
404 s = SwapUshort(header->gx_theme_header_magic_number);
405 memcpy_s(header_array, GX_THEME_HEADER_SIZE, &s, sizeof(USHORT));
406 index += sizeof(USHORT);
407
408 if (index < GX_THEME_HEADER_SIZE)
409 {
410 s = SwapUshort(header->gx_theme_header_index);
411 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(USHORT));
412 index += sizeof(USHORT);
413 }
414
415 if (index < GX_THEME_HEADER_SIZE)
416 {
417 s = SwapUshort(header->gx_theme_header_color_count);
418 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(USHORT));
419 index += sizeof(USHORT);
420 }
421
422 if (index < GX_THEME_HEADER_SIZE)
423 {
424 s = SwapUshort(header->gx_theme_header_palette_count);
425 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(USHORT));
426 index += sizeof(USHORT);
427 }
428
429 if (index < GX_THEME_HEADER_SIZE)
430 {
431 s = SwapUshort(header->gx_theme_header_font_count);
432 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(USHORT));
433 index += sizeof(USHORT);
434 }
435
436 if (index < GX_THEME_HEADER_SIZE)
437 {
438 s = SwapUshort(header->gx_theme_header_pixelmap_count);
439 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(USHORT));
440 index += sizeof(USHORT);
441 }
442
443 if (index < GX_THEME_HEADER_SIZE)
444 {
445 s = SwapUshort(header->gx_theme_header_vscroll_appearance.gx_scroll_width);
446 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
447 index += sizeof(SHORT);
448 }
449
450 if (index < GX_THEME_HEADER_SIZE)
451 {
452 s = SwapUshort(header->gx_theme_header_vscroll_appearance.gx_scroll_thumb_width);
453 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
454 index += sizeof(SHORT);
455 }
456
457 if (index < GX_THEME_HEADER_SIZE)
458 {
459 s = SwapUshort(header->gx_theme_header_vscroll_appearance.gx_scroll_thumb_travel_min);
460 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
461 index += sizeof(SHORT);
462 }
463
464 if (index < GX_THEME_HEADER_SIZE)
465 {
466 s = SwapUshort(header->gx_theme_header_vscroll_appearance.gx_scroll_thumb_travel_max);
467 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
468 index += sizeof(SHORT);
469 }
470
471 if (index + 1 < GX_THEME_HEADER_SIZE)
472 {
473 header_array[index++] = header->gx_theme_header_vscroll_appearance.gx_scroll_thumb_border_style;
474 l = SwapUint(header->gx_theme_header_vscroll_appearance.gx_scroll_fill_pixelmap);
475 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
476 index += sizeof(LONG);
477 }
478
479 if (index < GX_THEME_HEADER_SIZE)
480 {
481 l = SwapUint(header->gx_theme_header_vscroll_appearance.gx_scroll_thumb_pixelmap);
482 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
483 index += sizeof(LONG);
484 }
485
486 if (index < GX_THEME_HEADER_SIZE)
487 {
488 l = SwapUint(header->gx_theme_header_vscroll_appearance.gx_scroll_up_pixelmap);
489 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
490 index += sizeof(LONG);
491 }
492
493 if (index < GX_THEME_HEADER_SIZE)
494 {
495 l = SwapUint(header->gx_theme_header_vscroll_appearance.gx_scroll_down_pixelmap);
496 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
497 index += sizeof(LONG);
498 }
499
500 if (index < GX_THEME_HEADER_SIZE)
501 {
502 l = SwapUint(header->gx_theme_header_vscroll_appearance.gx_scroll_thumb_color);
503 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
504 index += sizeof(LONG);
505 }
506
507 if (index < GX_THEME_HEADER_SIZE)
508 {
509 l = SwapUint(header->gx_theme_header_vscroll_appearance.gx_scroll_thumb_border_color);
510 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
511 index += sizeof(LONG);
512 }
513
514 if (index < GX_THEME_HEADER_SIZE)
515 {
516 l = SwapUint(header->gx_theme_header_vscroll_appearance.gx_scroll_button_color);
517 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
518 index += sizeof(LONG);
519 }
520
521 if (index < GX_THEME_HEADER_SIZE)
522 {
523 s = SwapUshort(header->gx_theme_header_hscroll_appearance.gx_scroll_width);
524 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
525 index += sizeof(SHORT);
526 }
527
528 if (index < GX_THEME_HEADER_SIZE)
529 {
530 s = SwapUshort(header->gx_theme_header_hscroll_appearance.gx_scroll_thumb_width);
531 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
532 index += sizeof(SHORT);
533 }
534
535 if (index < GX_THEME_HEADER_SIZE)
536 {
537 s = SwapUshort(header->gx_theme_header_hscroll_appearance.gx_scroll_thumb_travel_min);
538 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
539 index += sizeof(SHORT);
540 }
541
542 if (index < GX_THEME_HEADER_SIZE)
543 {
544 s = SwapUshort(header->gx_theme_header_hscroll_appearance.gx_scroll_thumb_travel_max);
545 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &s, sizeof(SHORT));
546 index += sizeof(SHORT);
547 }
548
549 if (index + 1 < GX_THEME_HEADER_SIZE)
550 {
551 header_array[index++] = header->gx_theme_header_hscroll_appearance.gx_scroll_thumb_border_style;
552 l = SwapUint(header->gx_theme_header_hscroll_appearance.gx_scroll_fill_pixelmap);
553 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
554 index += sizeof(LONG);
555 }
556
557 if (index < GX_THEME_HEADER_SIZE)
558 {
559 l = SwapUint(header->gx_theme_header_hscroll_appearance.gx_scroll_thumb_pixelmap);
560 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
561 index += sizeof(LONG);
562 }
563
564 if (index < GX_THEME_HEADER_SIZE)
565 {
566 l = SwapUint(header->gx_theme_header_hscroll_appearance.gx_scroll_up_pixelmap);
567 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
568 index += sizeof(LONG);
569 }
570
571 if (index < GX_THEME_HEADER_SIZE)
572 {
573 l = SwapUint(header->gx_theme_header_hscroll_appearance.gx_scroll_down_pixelmap);
574 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
575 index += sizeof(LONG);
576 }
577
578 if (index < GX_THEME_HEADER_SIZE)
579 {
580 l = SwapUint(header->gx_theme_header_hscroll_appearance.gx_scroll_thumb_color);
581 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
582 index += sizeof(LONG);
583 }
584
585 if (index < GX_THEME_HEADER_SIZE)
586 {
587 l = SwapUint(header->gx_theme_header_hscroll_appearance.gx_scroll_thumb_border_color);
588 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
589 index += sizeof(LONG);
590 }
591
592 if (index < GX_THEME_HEADER_SIZE)
593 {
594 l = SwapUint(header->gx_theme_header_hscroll_appearance.gx_scroll_button_color);
595 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
596 index += sizeof(LONG);
597 }
598
599 if (index < GX_THEME_HEADER_SIZE)
600 {
601 l = SwapUint(header->gx_theme_header_vscroll_style);
602 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
603 index += sizeof(LONG);
604 }
605
606 if (index < GX_THEME_HEADER_SIZE)
607 {
608 l = SwapUint(header->gx_theme_header_hscroll_style);
609 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
610 index += sizeof(LONG);
611 }
612
613 if (index < GX_THEME_HEADER_SIZE)
614 {
615 l = SwapUint(header->gx_theme_header_color_data_size);
616 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
617 index += sizeof(LONG);
618 }
619
620 if (index < GX_THEME_HEADER_SIZE)
621 {
622 l = SwapUint(header->gx_theme_header_palette_data_size);
623 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
624 index += sizeof(LONG);
625 }
626
627 if (index < GX_THEME_HEADER_SIZE)
628 {
629 l = SwapUint(header->gx_theme_header_font_data_size);
630 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
631 index += sizeof(LONG);
632 }
633
634 if (index < GX_THEME_HEADER_SIZE)
635 {
636 l = SwapUint(header->gx_theme_header_pixelmap_data_size);
637 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
638 index += sizeof(LONG);
639 }
640
641 if (index < GX_THEME_HEADER_SIZE)
642 {
643 l = SwapUint(header->gx_theme_header_data_size);
644 memcpy_s(header_array + index, GX_THEME_HEADER_SIZE - index, &l, sizeof(LONG));
645 index += sizeof(LONG);
646 }
647
648 WriteDataOut(header_array, GX_THEME_HEADER_SIZE);
649 }
650
651 ///////////////////////////////////////////////////////////////////////////////
WriteColorHeader(GX_COLOR_HEADER * header)652 void binary_resource_gen::WriteColorHeader(GX_COLOR_HEADER *header)
653 {
654 UCHAR header_array[GX_COLOR_HEADER_SIZE];
655 int index = 0;
656 SHORT s;
657 LONG l;
658
659 s = SwapUshort(header->gx_color_header_magic_number);
660 memcpy_s(header_array, GX_COLOR_HEADER_SIZE, &s, sizeof(USHORT));
661 index += sizeof(USHORT);
662
663 if (index < GX_COLOR_HEADER_SIZE)
664 {
665 s = SwapUshort(header->gx_color_header_color_count);
666 memcpy_s(header_array + index, GX_COLOR_HEADER_SIZE - index, &s, sizeof(USHORT));
667 index += sizeof(USHORT);
668 }
669
670 if (index < GX_COLOR_HEADER_SIZE)
671 {
672 l = SwapUint(header->gx_color_header_data_size);
673 memcpy_s(header_array + index, GX_COLOR_HEADER_SIZE - index, &l, sizeof(ULONG));
674 index += sizeof(ULONG);
675 }
676
677 WriteDataOut(header_array, GX_COLOR_HEADER_SIZE);
678 }
679
680 ///////////////////////////////////////////////////////////////////////////////
WritePaletteHeader(GX_PALETTE_HEADER * header)681 void binary_resource_gen::WritePaletteHeader(GX_PALETTE_HEADER *header)
682 {
683 UCHAR header_array[GX_PALETTE_HEADER_SIZE];
684 int index = 0;
685 SHORT s;
686 LONG l;
687
688 s = SwapUshort(header->gx_palette_header_magic_number);
689 memcpy_s(header_array, GX_PALETTE_HEADER_SIZE, &s, sizeof(USHORT));
690 index += sizeof(USHORT);
691
692 if (index < GX_PALETTE_HEADER_SIZE)
693 {
694 s = SwapUshort(header->gx_palette_header_color_count);
695 memcpy_s(header_array + index, GX_PALETTE_HEADER_SIZE - index, &s, sizeof(USHORT));
696 index += sizeof(USHORT);
697 }
698
699 if (index < GX_PALETTE_HEADER_SIZE)
700 {
701 l = SwapUint(header->gx_palette_header_data_size);
702 memcpy_s(header_array + index, GX_PALETTE_HEADER_SIZE - index, &l, sizeof(ULONG));
703 index += sizeof(ULONG);
704 }
705
706 WriteDataOut(header_array, GX_PALETTE_HEADER_SIZE);
707 }
708
709 ///////////////////////////////////////////////////////////////////////////////
WriteFontHeader(GX_FONT_HEADER * header)710 void binary_resource_gen::WriteFontHeader(GX_FONT_HEADER *header)
711 {
712 UCHAR header_array[GX_FONT_HEADER_SIZE];
713 int index = 0;
714 SHORT s;
715 LONG l;
716
717 s = SwapUshort(header->gx_font_header_magic_number);
718 memcpy_s(header_array, GX_FONT_HEADER_SIZE, &s, sizeof(USHORT));
719 index += sizeof(USHORT);
720
721 if (index < GX_FONT_HEADER_SIZE)
722 {
723 s = SwapUshort(header->gx_font_header_index);
724 memcpy_s(header_array + index, GX_FONT_HEADER_SIZE - index, &s, sizeof(USHORT));
725 index += sizeof(USHORT);
726 }
727
728 if (index < GX_FONT_HEADER_SIZE)
729 {
730 s = SwapUshort(header->gx_font_header_page_count);
731 memcpy_s(header_array + index, GX_FONT_HEADER_SIZE - index, &s, sizeof(USHORT));
732 index += sizeof(USHORT);
733 }
734
735 if (index + 1 < GX_FONT_HEADER_SIZE)
736 {
737 header_array[index++] = header->gx_font_header_deault;
738 header_array[index++] = header->gx_font_header_bits;
739 }
740
741 if (index < GX_FONT_HEADER_SIZE)
742 {
743 l = SwapUint(header->gx_font_header_data_size);
744 memcpy_s(header_array + index, GX_FONT_HEADER_SIZE - index, &l, sizeof(ULONG));
745 index += sizeof(ULONG);
746 }
747
748 if ((project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX) && (index < GX_FONT_HEADER_SIZE))
749 {
750 l = SwapUint(header->gx_font_header_data_offset);
751 memcpy_s(header_array + index, GX_FONT_HEADER_SIZE - index, &l, sizeof(ULONG));
752 index += sizeof(ULONG);
753 }
754
755 WriteDataOut(header_array, GetFontHeaderSize());
756 }
757
758 ///////////////////////////////////////////////////////////////////////////////
WritePageHeader(GX_PAGE_HEADER * header)759 void binary_resource_gen::WritePageHeader(GX_PAGE_HEADER *header)
760 {
761 UCHAR header_array[GX_PAGE_HEADER_SIZE];
762 int index = 0;
763 SHORT s;
764 LONG l;
765
766 s = SwapUshort(header->gx_page_header_magic_number);
767 memcpy_s(header_array, GX_PAGE_HEADER_SIZE , &s, sizeof(USHORT));
768 index += sizeof(USHORT);
769
770 if (index < GX_PAGE_HEADER_SIZE)
771 {
772 s = SwapUshort(header->gx_page_header_index);
773 memcpy_s(header_array + index, GX_PAGE_HEADER_SIZE - index, &s, sizeof(USHORT));
774 index += sizeof(USHORT);
775 }
776
777 if (index + 4 < GX_PAGE_HEADER_SIZE)
778 {
779 header_array[index++] = header->gx_page_header_format;
780 header_array[index++] = header->gx_page_header_prespace;
781 header_array[index++] = header->gx_page_header_postspace;
782 header_array[index++] = header->gx_page_header_line_height;
783 header_array[index++] = header->gx_page_header_baseline;
784 }
785
786 if (index < GX_PAGE_HEADER_SIZE)
787 {
788 l = SwapUint((UINT)header->gx_page_header_first_glyph);
789 memcpy_s(header_array + index, GX_PAGE_HEADER_SIZE - index, &l, sizeof(ULONG));
790 index += sizeof(ULONG);
791 }
792
793 if (index < GX_PAGE_HEADER_SIZE)
794 {
795 l = SwapUint((UINT)header->gx_page_header_last_glyph);
796 memcpy_s(header_array + index, GX_PAGE_HEADER_SIZE - index, &l, sizeof(ULONG));
797 index += sizeof(ULONG);
798 }
799
800 if (index < GX_PAGE_HEADER_SIZE)
801 {
802 l = SwapUint(header->gx_page_header_data_size);
803 memcpy_s(header_array + index, GX_PAGE_HEADER_SIZE - index, &l, sizeof(ULONG));
804 index += sizeof(ULONG);
805 }
806
807 WriteDataOut(header_array, GX_PAGE_HEADER_SIZE);
808 }
809
810 ///////////////////////////////////////////////////////////////////////////////
WriteGlyphHeader(GX_GLYPH_HEADER * header)811 void binary_resource_gen::WriteGlyphHeader(GX_GLYPH_HEADER* header)
812 {
813 UCHAR header_array[GX_GLYPH_HEADER_SIZE];
814 int index = 0;
815 SHORT s;
816 LONG l;
817
818 s = SwapUshort(header->gx_glyph_header_magic_number);
819 memcpy_s(header_array, GX_GLYPH_HEADER_SIZE, &s, sizeof(USHORT));
820 index += sizeof(USHORT);
821
822 if (index < GX_GLYPH_HEADER_SIZE)
823 {
824 s = SwapUshort(header->gx_glyph_header_map_size);
825 memcpy_s(header_array + index, GX_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
826 index += sizeof(USHORT);
827 }
828
829 if ((project_lib_version() >= GX_VERSION_BINRES_FONT_ALIGNMENT_FIX) && (index < GX_GLYPH_HEADER_SIZE))
830 {
831 l = SwapUint(header->gx_glyph_header_map_offset);
832 memcpy_s(header_array + index, GX_GLYPH_HEADER_SIZE - index, &l, sizeof(ULONG));
833 index += sizeof(ULONG);
834 }
835
836 if (index < GX_GLYPH_HEADER_SIZE)
837 {
838 s = SwapUshort(header->gx_glyph_header_index);
839 memcpy_s(header_array + index, GX_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
840 index += sizeof(USHORT);
841 }
842
843 if (index < GX_GLYPH_HEADER_SIZE)
844 {
845 s = SwapUshort(header->gx_glyph_header_ascent);
846 memcpy_s(header_array + index, GX_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
847 index += sizeof(USHORT);
848 }
849
850 if (index < GX_GLYPH_HEADER_SIZE)
851 {
852 s = SwapUshort(header->gx_glyph_header_descent);
853 memcpy_s(header_array + index, GX_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
854 index += sizeof(USHORT);
855 }
856
857 if (index + 3 < GX_GLYPH_HEADER_SIZE)
858 {
859 header_array[index++] = header->gx_glyph_header_advance;
860 header_array[index++] = header->gx_glyph_header_leading;
861 header_array[index++] = header->gx_glyph_header_width;
862 header_array[index++] = header->gx_glyph_header_height;
863 }
864
865 if (index < GX_GLYPH_HEADER_SIZE)
866 {
867 l = SwapUint(header->gx_glyph_header_data_size);
868 memcpy_s(header_array + index, GX_GLYPH_HEADER_SIZE - index, &l, sizeof(ULONG));
869 }
870
871 WriteDataOut(header_array, GetGlyphHeaderSize());
872 }
873
874
875 ///////////////////////////////////////////////////////////////////////////////
WriteKerningGlyphHeader(GX_KERNING_GLYPH_HEADER * header)876 void binary_resource_gen::WriteKerningGlyphHeader(GX_KERNING_GLYPH_HEADER *header)
877 {
878 UCHAR header_array[GX_KERNING_GLYPH_HEADER_SIZE];
879 int index = 0;
880 SHORT s;
881 LONG l;
882
883 s = SwapUshort(header->gx_glyph_header_magic_number);
884 memcpy_s(header_array, GX_KERNING_GLYPH_HEADER_SIZE, &s, sizeof(USHORT));
885 index += sizeof(USHORT);
886
887 if (index < GX_KERNING_GLYPH_HEADER_SIZE)
888 {
889 s = SwapUshort(header->gx_glyph_header_map_size);
890 memcpy_s(header_array + index, GX_KERNING_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
891 index += sizeof(USHORT);
892 }
893
894 if ((project_lib_version() >= GX_VERSION_BINRES_FONT_ALIGNMENT_FIX) && (index < GX_GLYPH_HEADER_SIZE))
895 {
896 l = SwapUint(header->gx_glyph_header_map_offset);
897 memcpy_s(header_array + index, GX_GLYPH_HEADER_SIZE - index, &l, sizeof(ULONG));
898 index += sizeof(ULONG);
899 }
900
901 if (index < GX_KERNING_GLYPH_HEADER_SIZE)
902 {
903 s = SwapUshort(header->gx_glyph_header_index);
904 memcpy_s(header_array + index, GX_KERNING_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
905 index += sizeof(USHORT);
906 }
907
908 if (index < GX_KERNING_GLYPH_HEADER_SIZE)
909 {
910 s = SwapUshort(header->gx_glyph_header_ascent);
911 memcpy_s(header_array + index, GX_KERNING_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
912 index += sizeof(USHORT);
913 }
914
915 if (index < GX_KERNING_GLYPH_HEADER_SIZE)
916 {
917 s = SwapUshort(header->gx_glyph_header_descent);
918 memcpy_s(header_array + index, GX_KERNING_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
919 index += sizeof(USHORT);
920 }
921
922 if (index + 3 < GX_KERNING_GLYPH_HEADER_SIZE)
923 {
924 header_array[index++] = header->gx_glyph_header_advance;
925 header_array[index++] = header->gx_glyph_header_leading;
926 header_array[index++] = header->gx_glyph_header_width;
927 header_array[index++] = header->gx_glyph_header_height;
928 }
929
930 if (index < GX_KERNING_GLYPH_HEADER_SIZE)
931 {
932 l = SwapUint(header->gx_glyph_header_data_size);
933 memcpy_s(header_array + index, GX_KERNING_GLYPH_HEADER_SIZE - index, &l, sizeof(ULONG));
934 index += sizeof(ULONG);
935 }
936
937 if (index < GX_KERNING_GLYPH_HEADER_SIZE)
938 {
939 s = SwapUshort(header->gx_glyph_header_kerning_table_size);
940 memcpy_s(header_array + index, GX_KERNING_GLYPH_HEADER_SIZE - index, &s, sizeof(USHORT));
941 }
942
943 WriteDataOut(header_array, GetKerningGlyphHeaderSize());
944 }
945
946 ///////////////////////////////////////////////////////////////////////////////
WritePixelmapHeader(GX_PIXELMAP_HEADER * header)947 void binary_resource_gen::WritePixelmapHeader(GX_PIXELMAP_HEADER *header)
948 {
949 UCHAR header_array[GX_PIXELMAP_HEADER_SIZE];
950 int index = 0;
951 SHORT s;
952 LONG l;
953
954 s = SwapUshort(header->gx_pixelmap_header_magic_number);
955 memcpy_s(header_array, GX_PIXELMAP_HEADER_SIZE, &s, sizeof(USHORT));
956 index += sizeof(USHORT);
957
958 if (index < GX_PIXELMAP_HEADER_SIZE)
959 {
960 s = SwapUshort(header->gx_pixelmap_header_index);
961 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &s, sizeof(USHORT));
962 index += sizeof(USHORT);
963 }
964
965 if (index + 3 < GX_PIXELMAP_HEADER_SIZE)
966 {
967 header_array[index++] = header->gx_pixelmap_header_version_major;
968 header_array[index++] = header->gx_pixelmap_header_version_minor;
969 header_array[index++] = header->gx_pixelmap_header_flags;
970 header_array[index++] = header->gx_pixelmap_header_format;
971 }
972
973 if (index < GX_PIXELMAP_HEADER_SIZE)
974 {
975 l = SwapUint(header->gx_pixelmap_header_map_size);
976 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &l, sizeof(ULONG));
977 index += sizeof(ULONG);
978 }
979
980 if (index < GX_PIXELMAP_HEADER_SIZE)
981 {
982 l = SwapUint(header->gx_pixelmap_header_aux_data_size);
983 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &l, sizeof(ULONG));
984 index += sizeof(ULONG);
985 }
986
987 if (index < GX_PIXELMAP_HEADER_SIZE)
988 {
989 l = SwapUint(header->gx_pixelmap_header_transparent_color);
990 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &l, sizeof(GX_COLOR));
991 index += sizeof(GX_COLOR);
992 }
993
994 if (index < GX_PIXELMAP_HEADER_SIZE)
995 {
996 s = SwapUshort(header->gx_pixelmap_header_width);
997 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &s, sizeof(USHORT));
998 index += sizeof(USHORT);
999 }
1000
1001 if (index < GX_PIXELMAP_HEADER_SIZE)
1002 {
1003 s = SwapUshort(header->gx_pixelmap_header_height);
1004 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &s, sizeof(USHORT));
1005 index += sizeof(USHORT);
1006 }
1007
1008 if (index < GX_PIXELMAP_HEADER_SIZE)
1009 {
1010 l = SwapUint(header->gx_pixelmap_header_data_size);
1011 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &l, sizeof(ULONG));
1012 index += sizeof(ULONG);
1013 }
1014
1015 if ((project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX) && (index < GX_PIXELMAP_HEADER_SIZE))
1016 {
1017 l = SwapUint(header->gx_pixelmap_header_data_offset);
1018 memcpy_s(header_array + index, GX_PIXELMAP_HEADER_SIZE - index, &l, sizeof(ULONG));
1019 index += sizeof(ULONG);
1020 }
1021
1022 WriteDataOut(header_array, GetPixelmapHeaderSize());
1023 }
1024
1025 ///////////////////////////////////////////////////////////////////////////////
WriteStringHeader(GX_STRING_HEADER * header)1026 void binary_resource_gen::WriteStringHeader(GX_STRING_HEADER *header)
1027 {
1028 UCHAR header_array[GX_STRING_HEADER_SIZE];
1029 int index = 0;
1030 SHORT s;
1031 LONG l;
1032
1033 s = SwapUshort(header->gx_string_header_magic_number);
1034 memcpy_s(header_array, GX_STRING_HEADER_SIZE, &s, sizeof(USHORT));
1035 index += sizeof(USHORT);
1036
1037 if (index < GX_STRING_HEADER_SIZE)
1038 {
1039 s = SwapUshort(header->gx_string_header_language_count);
1040 memcpy_s(header_array + index, GX_STRING_HEADER_SIZE - index, &s, sizeof(USHORT));
1041 index += sizeof(USHORT);
1042 }
1043
1044 if (index < GX_STRING_HEADER_SIZE)
1045 {
1046 s = SwapUshort(header->gx_string_header_string_count);
1047 memcpy_s(header_array + index, GX_STRING_HEADER_SIZE - index, &s, sizeof(USHORT));
1048 index += sizeof(USHORT);
1049 }
1050
1051 if (index < GX_STRING_HEADER_SIZE)
1052 {
1053 l = SwapUint(header->gx_string_header_data_size);
1054 memcpy_s(header_array + index, GX_STRING_HEADER_SIZE - index, &l, sizeof(ULONG));
1055 }
1056
1057 WriteDataOut(header_array, GX_STRING_HEADER_SIZE);
1058 }
1059
1060 ///////////////////////////////////////////////////////////////////////////////
WriteLanguageHeader(GX_LANGUAGE_HEADER * header)1061 void binary_resource_gen::WriteLanguageHeader(GX_LANGUAGE_HEADER *header)
1062 {
1063 UCHAR header_array[GX_LANGUAGE_HEADER_SIZE];
1064 int index = 0;
1065 SHORT s;
1066 LONG l;
1067
1068 s = SwapUshort(header->gx_language_header_magic_number);
1069 memcpy_s(header_array, GX_LANGUAGE_HEADER_SIZE, &s, sizeof(USHORT));
1070 index += sizeof(USHORT);
1071
1072 if (index < GX_LANGUAGE_HEADER_SIZE)
1073 {
1074 s = SwapUshort(header->gx_language_header_index);
1075 memcpy_s(header_array + index, GX_LANGUAGE_HEADER_SIZE - index, &s, sizeof(USHORT));
1076 index += sizeof(USHORT);
1077 }
1078
1079 if (index < GX_LANGUAGE_HEADER_SIZE)
1080 {
1081 memcpy_s(header_array + index, GX_LANGUAGE_HEADER_SIZE - index, header->gx_language_header_name, GX_LANGUAGE_HEADER_NAME_SIZE);
1082 index += GX_LANGUAGE_HEADER_NAME_SIZE;
1083 }
1084
1085 if (index < GX_LANGUAGE_HEADER_SIZE)
1086 {
1087 l = SwapUint(header->gx_language_header_data_size);
1088 memcpy_s(header_array + index, GX_LANGUAGE_HEADER_SIZE - index, &l, sizeof(ULONG));
1089 index += sizeof(ULONG);
1090 }
1091
1092 WriteDataOut(header_array, GX_LANGUAGE_HEADER_SIZE);
1093 }
1094
1095 ///////////////////////////////////////////////////////////////////////////////
WriteStandaloneResHeader()1096 void binary_resource_gen::WriteStandaloneResHeader()
1097 {
1098 if (m_written_size)
1099 {
1100 return;
1101 }
1102
1103 file_info* info;
1104 CString filename = RemoveFileExtension(m_outfile->GetFileName());
1105 filename.MakeUpper();
1106
1107 info = FindFileInfo(&m_file_dictionary, filename);
1108 if (!info)
1109 {
1110 info = m_file_dictionary.GetAt(0);
1111 }
1112
1113 UCHAR header_array[GX_RESOURCE_STANDALONE_HEADER_SIZE];
1114 int index = 0;
1115 SHORT s;
1116 LONG l;
1117 ULONG offset;
1118 int res_count = info->size_table.GetCount();
1119
1120 // Write resource type.
1121 s = SwapUshort(GX_RESOURCE_TYPE_BINRES_STANDALONE);
1122 memcpy_s(header_array, GX_RESOURCE_STANDALONE_HEADER_SIZE, &s, sizeof(USHORT));
1123 index += sizeof(USHORT);
1124
1125 // Write version.
1126 if (index < GX_RESOURCE_STANDALONE_HEADER_SIZE)
1127 {
1128 s = SwapUshort(m_project->mHeader.guix_version);
1129 memcpy_s(header_array + index, GX_RESOURCE_STANDALONE_HEADER_SIZE - index, &s, sizeof(USHORT));
1130 index += sizeof(USHORT);
1131 }
1132
1133 // Write resource count.
1134 if (index < GX_RESOURCE_STANDALONE_HEADER_SIZE)
1135 {
1136 l = SwapUint(res_count);
1137 memcpy_s(header_array + index, GX_RESOURCE_STANDALONE_HEADER_SIZE - index, &l, sizeof(ULONG));
1138 index += sizeof(ULONG);
1139 }
1140
1141 WriteDataOut(header_array, GX_RESOURCE_STANDALONE_HEADER_SIZE);
1142
1143 if (res_count > 1)
1144 {
1145 // Generate offset table when more than one resource is generated to one binary file.
1146 offset = m_written_size + sizeof(ULONG) * res_count;
1147
1148 for (int index = 0; index < res_count; index++)
1149 {
1150 l = SwapUint(offset);
1151 WriteDataOut((void*)&l, sizeof(ULONG));
1152
1153 offset += info->size_table.GetAt(index);
1154 }
1155 }
1156 }
1157
1158 ///////////////////////////////////////////////////////////////////////////////
SwapUshort(USHORT s)1159 USHORT binary_resource_gen::SwapUshort(USHORT s)
1160 {
1161 if (m_big_endian)
1162 {
1163 UCHAR b1, b2;
1164
1165 b1 = s & 0xff;
1166 b2 = (s >> 8) & 0xff;
1167
1168 return (b1 << 8) + b2;
1169 }
1170 else
1171 {
1172 return s;
1173 }
1174 }
1175
1176 ///////////////////////////////////////////////////////////////////////////////
SwapUint(UINT l)1177 UINT binary_resource_gen::SwapUint(UINT l)
1178 {
1179 if (m_big_endian)
1180 {
1181 UCHAR b1, b2, b3, b4;
1182
1183 b1 = l & 0xff;
1184 b2 = (l >> 8) & 0xff;
1185 b3 = (l >> 16) & 0xff;
1186 b4 = (l >> 24) & 0xff;
1187
1188 return ((LONG)b1 << 24) + ((LONG)b2 << 16) + ((LONG)b3 << 8) + b4;
1189 }
1190 else
1191 {
1192 return l;
1193 }
1194 }
1195
1196 ///////////////////////////////////////////////////////////////////////////////
WriteThemeBlock(USHORT theme_id)1197 void binary_resource_gen::WriteThemeBlock(USHORT theme_id)
1198 {
1199 if (!m_project)
1200 {
1201 return;
1202 }
1203
1204 GX_THEME_HEADER header;
1205
1206 header.gx_theme_header_magic_number = GX_MAGIC_NUMBER;
1207 header.gx_theme_header_index = theme_id;
1208 header.gx_theme_header_color_count = GetColorCount(theme_id);
1209 if (m_project->mDisplays[m_display].colorformat == GX_COLOR_FORMAT_8BIT_PALETTE &&
1210 m_project->mDisplays[m_display].themes[theme_id].palette != NULL)
1211 {
1212 /* ONly 8bit palette size is wanted to be generated.
1213 4bpp driver contains palette table. But it is just used inside Studio.*/
1214 header.gx_theme_header_palette_count = m_project->mDisplays[m_display].themes[theme_id].palette_total_size;
1215 }
1216 else
1217 {
1218 header.gx_theme_header_palette_count = 0;
1219 }
1220
1221 header.gx_theme_header_font_count = GetFontCount(theme_id);
1222 header.gx_theme_header_pixelmap_count = GetPixelmapCount(theme_id);
1223 header.gx_theme_header_color_data_size = GetColorBlockSize(theme_id);
1224 header.gx_theme_header_palette_data_size = GetPaletteBlockSize(theme_id);
1225
1226 ULONG written_size = m_written_size;
1227 written_size += GetThemeHeaderSize();
1228 written_size += header.gx_theme_header_color_data_size;
1229 written_size += header.gx_theme_header_palette_data_size;
1230
1231 header.gx_theme_header_font_data_size = GetFontBlockSize(written_size, theme_id, -1);
1232
1233 written_size += header.gx_theme_header_font_data_size;
1234
1235 header.gx_theme_header_pixelmap_data_size = GetPixelmapBlockSize(written_size, theme_id, -1, -1);
1236 /* calculate theme data size. */
1237 header.gx_theme_header_data_size = header.gx_theme_header_color_data_size;
1238 header.gx_theme_header_data_size += header.gx_theme_header_palette_data_size;
1239 header.gx_theme_header_data_size += header.gx_theme_header_font_data_size;
1240 header.gx_theme_header_data_size += header.gx_theme_header_pixelmap_data_size;
1241
1242 memcpy_s(&header.gx_theme_header_vscroll_appearance,
1243 sizeof(header.gx_theme_header_vscroll_appearance),
1244 &m_project->mDisplays[m_display].themes[theme_id].VScrollAppearance, sizeof(GX_SCROLLBAR_APPEARANCE));
1245
1246 memcpy_s(&header.gx_theme_header_hscroll_appearance,
1247 sizeof(header.gx_theme_header_hscroll_appearance),
1248 &m_project->mDisplays[m_display].themes[theme_id].HScrollAppearance, sizeof(GX_SCROLLBAR_APPEARANCE));
1249
1250 header.gx_theme_header_vscroll_style = m_project->mDisplays[m_display].themes[theme_id].VScrollStyle;
1251 header.gx_theme_header_hscroll_style = m_project->mDisplays[m_display].themes[theme_id].HScrollStyle;
1252
1253 // Write theme header
1254 WriteThemeHeader(&header);
1255
1256 // Write theme data
1257 theme_info *info = &m_project->mDisplays[m_display].themes[theme_id];
1258 CCommandInfo *pCmd = GetCmdInfo();
1259 BOOL gen_color_table;
1260 BOOL gen_font_table;
1261 BOOL gen_pixelmap_table;
1262
1263 if (pCmd->IsNoGui())
1264 {
1265 gen_color_table = TRUE;
1266 gen_font_table = TRUE;
1267 gen_pixelmap_table = TRUE;
1268 }
1269 else
1270 {
1271 gen_color_table = info->gen_color_table;
1272 gen_font_table = info->gen_font_table;
1273 gen_pixelmap_table = info->gen_pixelmap_table;
1274 }
1275
1276 if (gen_color_table &&
1277 header.gx_theme_header_color_count)
1278 {
1279 WriteColorBlock(theme_id);
1280 }
1281
1282 if (info->palette &&
1283 header.gx_theme_header_palette_count)
1284 {
1285 WritePaletteBlock(theme_id);
1286 }
1287
1288 if (gen_font_table &&
1289 header.gx_theme_header_font_count)
1290 {
1291 int font_id;
1292
1293 for (font_id = 0; font_id < m_project->CountResources(m_display, RES_TYPE_FONT); font_id++)
1294 {
1295 res_info *info = m_project->FindResource(m_display, theme_id, RES_TYPE_FONT, font_id);
1296
1297 if (info)
1298 {
1299 WriteFontBlock(info, font_id, theme_id);
1300 }
1301 }
1302 }
1303
1304 if (gen_pixelmap_table &&
1305 header.gx_theme_header_pixelmap_count)
1306 {
1307 int pixelmap_id;
1308 int frame_id;
1309 int output_id = 1;
1310
1311 for (pixelmap_id = 1; pixelmap_id < m_pixelmap_dictionary.GetCount(); pixelmap_id++)
1312 {
1313 res_info *info = m_project->FindResource(m_display, theme_id, RES_TYPE_PIXELMAP, m_pixelmap_dictionary.GetAt(pixelmap_id));
1314
1315 if (info && info->GetPixelmapFrameCount() && (info->enabled) && (info->parent->enabled))
1316 {
1317 for (frame_id = 0; frame_id < info->GetPixelmapFrameCount(); frame_id++)
1318 {
1319 WritePixelmapBlock(info, pixelmap_id, output_id++, theme_id, frame_id);
1320 }
1321 }
1322 else if (IsSystemPixelmap(pixelmap_id))
1323 {
1324 output_id++;
1325 }
1326 }
1327 }
1328 }
1329
1330 ///////////////////////////////////////////////////////////////////////////////
WriteColorBlock(int theme_id)1331 void binary_resource_gen::WriteColorBlock(int theme_id)
1332 {
1333 int color_count = GetColorCount(theme_id);
1334
1335 GX_COLOR_HEADER header;
1336 header.gx_color_header_magic_number = GX_MAGIC_NUMBER;
1337 header.gx_color_header_color_count = color_count;
1338 header.gx_color_header_data_size = color_count * sizeof(GX_COLOR);
1339
1340 //Write Color Header
1341 WriteColorHeader(&header);
1342
1343 //Write color data
1344 int color_id;
1345 GX_COLOR rgb_color;
1346 GX_COLOR native_color;
1347 int color_format;
1348
1349 color_format = m_project->mDisplays[m_display].colorformat;
1350
1351 // write color table data
1352 for (color_id = 0; color_id < m_project->CountResources(m_display, RES_TYPE_COLOR); color_id++)
1353 {
1354 res_info *info = m_project->FindResource(m_display, theme_id, RES_TYPE_COLOR, color_id);
1355
1356 if (info)
1357 {
1358 rgb_color = info->colorval;
1359 native_color = resource_view::GetNativeColor(rgb_color, color_format);
1360
1361 native_color = SwapUint(native_color);
1362
1363 WriteDataOut(&native_color, sizeof(GX_COLOR));
1364 }
1365 }
1366 }
1367
1368 ///////////////////////////////////////////////////////////////////////////////
WritePaletteBlock(int theme_id)1369 void binary_resource_gen::WritePaletteBlock(int theme_id)
1370 {
1371 theme_info *info = &m_project->mDisplays[m_display].themes[theme_id];
1372 int color_count = info->palette_total_size;
1373 int palette_index;
1374 GX_COLOR rgb_color;
1375
1376 if (color_count)
1377 {
1378 GX_PALETTE_HEADER header;
1379 header.gx_palette_header_magic_number = GX_MAGIC_NUMBER;
1380 header.gx_palette_header_color_count = color_count;
1381 header.gx_palette_header_data_size = color_count * sizeof(GX_COLOR);
1382
1383 //Write Palette Header
1384 WritePaletteHeader(&header);
1385
1386 //Write palette data
1387
1388 for (palette_index = 0; palette_index < color_count; palette_index++)
1389 {
1390 rgb_color = SwapUint(info->palette[palette_index]);
1391 WriteDataOut(&rgb_color, sizeof(ULONG));
1392 }
1393 }
1394 }
1395
1396
1397 ///////////////////////////////////////////////////////////////////////////////
WriteFontBlock(res_info * info,USHORT font_id,USHORT theme_id)1398 void binary_resource_gen::WriteFontBlock(res_info *info, USHORT font_id, USHORT theme_id)
1399 {
1400 GX_FONT_HEADER header;
1401 int reference_theme = -1;
1402 USHORT output_font_id = font_id;
1403
1404 if (m_file_format == BINARY_FILE_FORMAT_BIN_STANDALONE)
1405 {
1406 CString filename = RemoveFileExtension(m_outfile->GetFileName());
1407 filename.MakeUpper();
1408
1409 file_info *finfo = FindFileInfo(&m_file_dictionary, filename);
1410 if (!finfo)
1411 {
1412 finfo = m_file_dictionary.GetAt(0);
1413 }
1414 output_font_id = finfo->write_res_index++;
1415 }
1416
1417 memset(&header, 0, sizeof(GX_FONT_HEADER));
1418 header.gx_font_header_magic_number = GX_MAGIC_NUMBER;
1419 header.gx_font_header_index = output_font_id;
1420 header.gx_font_header_page_count = GetPageCount(info, theme_id, font_id);
1421 header.gx_font_header_bits = info->font_bits;
1422
1423 if (info->is_default && info->pathinfo.pathname.IsEmpty() &&
1424 !IsRotatedResourceSupported(m_project, m_display))
1425 {
1426 header.gx_font_header_deault = TRUE;
1427 }
1428 else
1429 {
1430 header.gx_font_header_deault = FALSE;
1431
1432 if (project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX)
1433 {
1434 reference_theme = FindResourceReferenceTheme(info, theme_id);
1435 }
1436 }
1437
1438 if (reference_theme >= 0)
1439 {
1440 header.gx_font_header_data_offset = GetFontDataOffset(font_id, reference_theme);
1441
1442 //write font header
1443 WriteFontHeader(&header);
1444 }
1445 else
1446 {
1447 header.gx_font_header_data_size = GetFontDataSize(m_written_size + GetFontHeaderSize(), info, theme_id, font_id);
1448
1449 //write font header
1450 WriteFontHeader(&header);
1451
1452 //write font data
1453 WriteFontData(info, theme_id, font_id);
1454 }
1455 }
1456
1457 ///////////////////////////////////////////////////////////////////////////////
WriteFontData(res_info * info,USHORT theme_id,USHORT font_id)1458 void binary_resource_gen::WriteFontData(res_info *info, USHORT theme_id, USHORT font_id)
1459 {
1460
1461 const GX_FONT *font_page;
1462 GX_FONT *head_page;
1463 int page_index;
1464
1465 if (info->is_default && info->pathinfo.pathname.IsEmpty() &&
1466 !IsRotatedResourceSupported(m_project, m_display))
1467 {
1468 return;
1469 }
1470
1471 head_page = GetPageHead(info, theme_id, font_id);
1472
1473 //write font data
1474 font_page = head_page;
1475 page_index = 1;
1476 while (font_page)
1477 {
1478 WritePageBlock(font_page, page_index);
1479
1480 page_index++;
1481 font_page = font_page->gx_font_next_page;
1482 }
1483 }
1484
1485
1486 ///////////////////////////////////////////////////////////////////////////////
WritePageBlock(const GX_FONT * font,USHORT page_id)1487 void binary_resource_gen::WritePageBlock(const GX_FONT *font, USHORT page_id)
1488 {
1489 if (!font)
1490 {
1491 return;
1492 }
1493
1494 GX_PAGE_HEADER header;
1495 header.gx_page_header_magic_number = GX_MAGIC_NUMBER;
1496 header.gx_page_header_index = page_id;
1497 header.gx_page_header_format = font->gx_font_format;
1498 header.gx_page_header_prespace = font->gx_font_prespace;
1499 header.gx_page_header_postspace = font->gx_font_postspace;
1500 header.gx_page_header_line_height = font->gx_font_line_height;
1501 header.gx_page_header_baseline = font->gx_font_baseline;
1502 header.gx_page_header_first_glyph = font->gx_font_first_glyph;
1503 header.gx_page_header_last_glyph = font->gx_font_last_glyph;
1504 header.gx_page_header_data_size = GetPageDataSize(m_written_size + GetPageHeaderSize(), font);
1505
1506 if (IsRotatedResourceSupported(m_project, m_display))
1507 {
1508 switch (m_project->mDisplays[m_display].rotation_angle)
1509 {
1510 case GX_SCREEN_ROTATION_CW:
1511 header.gx_page_header_format |= GX_FONT_FORMAT_ROTATED_90;
1512 break;
1513 case GX_SCREEN_ROTATION_CCW:
1514 header.gx_page_header_format |= GX_FONT_FORMAT_ROTATED_270;
1515 break;
1516 }
1517 }
1518
1519 //Write font page header
1520 WritePageHeader(&header);
1521
1522 // Write font page data
1523 GX_CHAR_CODE charval;
1524 INT glyph_index;
1525
1526 for (charval = font->gx_font_first_glyph; charval <= font->gx_font_last_glyph; charval++)
1527 {
1528 glyph_index = charval - font->gx_font_first_glyph;
1529 WriteGlyphBock(font, glyph_index);
1530 }
1531 }
1532
1533 ///////////////////////////////////////////////////////////////////////////////
WriteGlyphBock(const GX_FONT * font,USHORT glyph_index)1534 void binary_resource_gen::WriteGlyphBock(const GX_FONT *font, USHORT glyph_index)
1535 {
1536 studiox_project *project = GetOpenProject();
1537 if (project)
1538 {
1539 const GX_GLYPH *glyph = NULL;
1540 GX_KERNING_GLYPH_HEADER header;
1541
1542 if (font->gx_font_format & GX_FONT_FORMAT_COMPRESSED)
1543 {
1544 const GX_COMPRESSED_GLYPH *compressed_glyph = &font ->gx_font_glyphs.gx_font_compressed_glyphs[glyph_index];
1545 header.gx_glyph_header_map_size = compressed_glyph->gx_glyph_map_size;
1546 glyph = (const GX_GLYPH *)compressed_glyph;
1547 }
1548 else if (font->gx_font_format & GX_FONT_FORMAT_KERNING)
1549 {
1550 const GX_KERNING_GLYPH *kerning_glyph = &font->gx_font_glyphs.gx_font_kerning_glyphs[glyph_index];
1551 header.gx_glyph_header_map_size = 0;
1552 glyph = (const GX_GLYPH *)kerning_glyph;
1553 }
1554 else
1555 {
1556 glyph = &font->gx_font_glyphs.gx_font_normal_glyphs[glyph_index];
1557 header.gx_glyph_header_map_size = 0;
1558 }
1559
1560 const UCHAR *data = glyph->gx_glyph_map;
1561 UCHAR *rotated_data = NULL;
1562 int map_size = header.gx_glyph_header_map_size;
1563 int map_data_pos;
1564
1565 if (IsRotatedResourceSupported(m_project, m_display))
1566 {
1567 RotateGlyphData(glyph, font->gx_font_format, &rotated_data, &map_size);
1568
1569 header.gx_glyph_header_map_size = map_size;
1570
1571 data = rotated_data;
1572 }
1573
1574 header.gx_glyph_header_magic_number = GX_MAGIC_NUMBER;
1575 header.gx_glyph_header_index = glyph_index;
1576 header.gx_glyph_header_ascent = glyph->gx_glyph_ascent;
1577 header.gx_glyph_header_descent = glyph->gx_glyph_descent;
1578 header.gx_glyph_header_advance = glyph->gx_glyph_advance;
1579 header.gx_glyph_header_leading = glyph->gx_glyph_leading;
1580 header.gx_glyph_header_width = glyph->gx_glyph_width;
1581 header.gx_glyph_header_height = glyph->gx_glyph_height;
1582 header.gx_glyph_header_kerning_table_size = 0;
1583 header.gx_glyph_header_map_offset = (m_written_size - m_written_start_address);
1584
1585 if (font->gx_font_format & GX_FONT_FORMAT_KERNING)
1586 {
1587 header.gx_glyph_header_map_offset += GX_KERNING_GLYPH_HEADER_SIZE;
1588 map_data_pos = m_written_size + GetKerningGlyphHeaderSize();
1589 }
1590 else
1591 {
1592 header.gx_glyph_header_map_offset += GX_GLYPH_HEADER_SIZE;
1593 map_data_pos = m_written_size + GetGlyphHeaderSize();
1594 }
1595
1596 if (header.gx_glyph_header_map_offset & 0x03)
1597 {
1598 header.gx_glyph_header_map_offset = (header.gx_glyph_header_map_offset + 3) & (~0x03UL);
1599 }
1600
1601 if (map_size)
1602 {
1603 header.gx_glyph_header_data_size = map_size & 0x7fff;
1604 if (map_data_pos & 0x03)
1605 {
1606 header.gx_glyph_header_data_size += (4 - (map_data_pos & 0x03));
1607 }
1608 }
1609 else
1610 {
1611 header.gx_glyph_header_data_size = GetGlyphDataSize(map_data_pos, font, glyph_index);
1612 }
1613
1614 if (font->gx_font_format & GX_FONT_FORMAT_KERNING)
1615 {
1616 header.gx_glyph_header_kerning_table_size = GetGlyphKerningTableSize(font, glyph_index);
1617 WriteKerningGlyphHeader(&header);
1618 }
1619 else
1620 {
1621 // Write glyph header
1622 WriteGlyphHeader((GX_GLYPH_HEADER *)&header);
1623 }
1624
1625 // Write Glyph Data
1626 if (data)
1627 {
1628 int padding = 0;
1629
1630 if ((project_lib_version() >= GX_VERSION_BINRES_FONT_ALIGNMENT_FIX) &&
1631 (m_written_size & 0x03))
1632 {
1633 padding = 4 - (m_written_size & 0x03);
1634 WriteDataOut(filling_string, padding);
1635 }
1636
1637 WriteDataOut(data, header.gx_glyph_header_data_size - padding);
1638 }
1639
1640 if (rotated_data)
1641 {
1642 delete rotated_data;
1643 }
1644
1645 if (font -> gx_font_format & GX_FONT_FORMAT_KERNING)
1646 {
1647 if (header.gx_glyph_header_kerning_table_size)
1648 {
1649 WriteDataOut(((GX_KERNING_GLYPH *)glyph)->gx_kerning_table, header.gx_glyph_header_kerning_table_size);
1650 }
1651 }
1652 }
1653 }
1654
1655 ///////////////////////////////////////////////////////////////////////////////
WriteBigEndianUintData(GX_PIXELMAP * map)1656 VOID binary_resource_gen::WriteBigEndianUintData(GX_PIXELMAP *map)
1657 {
1658 UINT *swap_data = new UINT[map->gx_pixelmap_data_size / 4];
1659 UINT *data_p = (UINT *)map->gx_pixelmap_data;
1660 UINT val;
1661
1662 for (UINT i = 0; i < map->gx_pixelmap_data_size / 4; i++)
1663 {
1664 val = SwapUint(*data_p);
1665 swap_data[i] = val;
1666 data_p++;
1667 }
1668
1669 WriteDataOut(swap_data, map->gx_pixelmap_data_size);
1670
1671 delete swap_data;
1672 }
1673
1674 ///////////////////////////////////////////////////////////////////////////////
WriteBigEndianUshortData(GX_PIXELMAP * map)1675 VOID binary_resource_gen::WriteBigEndianUshortData(GX_PIXELMAP *map)
1676 {
1677 USHORT *swap_data = new USHORT[map->gx_pixelmap_data_size / 2];
1678 USHORT *data_p = (USHORT *)map->gx_pixelmap_data;
1679 USHORT val;
1680
1681 for (UINT i = 0; i < map->gx_pixelmap_data_size / 2; i++)
1682 {
1683 val = SwapUshort(*data_p);
1684 swap_data[i] = val;
1685 data_p++;
1686 }
1687
1688 WriteDataOut(swap_data, map->gx_pixelmap_data_size);
1689
1690 delete swap_data;
1691 }
1692
1693 ///////////////////////////////////////////////////////////////////////////////
WriteBigEndianCompressedUshortData(GX_PIXELMAP * map)1694 VOID binary_resource_gen::WriteBigEndianCompressedUshortData(GX_PIXELMAP *map)
1695 {
1696 USHORT *swap_data = new USHORT[map->gx_pixelmap_data_size / 2];
1697 USHORT *data_p = (USHORT *)map->gx_pixelmap_data;
1698 USHORT val;
1699
1700 for (UINT i = 0; i < map->gx_pixelmap_data_size / 2; i++)
1701 {
1702 swap_data[i++] = *data_p;
1703 data_p++;
1704
1705 val = SwapUshort(*data_p);
1706 swap_data[i] = val;
1707 data_p++;
1708 }
1709
1710 WriteDataOut(swap_data, map->gx_pixelmap_data_size);
1711
1712 delete swap_data;
1713 }
1714
1715 ///////////////////////////////////////////////////////////////////////////////
WriteOneSRecord()1716 VOID binary_resource_gen::WriteOneSRecord()
1717 {
1718 INT srec_type;
1719 if (m_srec_address <= 0xffff)
1720 {
1721 srec_type = SREC_TYPE_S1;
1722 }
1723 else if (m_srec_address <= 0xffffff)
1724 {
1725 srec_type = SREC_TYPE_S2;
1726 }
1727 else
1728 {
1729 srec_type = SREC_TYPE_S3;
1730 }
1731
1732 WriteOneSRecord(srec_type);
1733 }
1734
1735 ///////////////////////////////////////////////////////////////////////////////
WriteOneSRecord(INT type)1736 VOID binary_resource_gen::WriteOneSRecord(INT type)
1737 {
1738 ULONG crc = 0;
1739 char buffer[80];
1740 int write_size = 0;
1741 int count = m_srec_data_size;
1742
1743 buffer[0] = 'S';
1744 switch (type)
1745 {
1746 case SREC_TYPE_S0:
1747 count += 3;
1748 crc += count;
1749 buffer[1] = '0';
1750 sprintf_s(buffer + 2, sizeof(buffer) - 2, "%02X", count);
1751 sprintf_s(buffer + 4, sizeof(buffer) - 4, "%04X", 0);
1752 write_size = 8;
1753 break;
1754
1755 case SREC_TYPE_S1:
1756 count += 3;
1757 crc += count;
1758 crc += m_srec_address & 0xff;
1759 crc += m_srec_address >> 8;
1760 buffer[1] = '1';
1761 sprintf_s(buffer + 2, sizeof(buffer) - 2, "%02X", count);
1762 sprintf_s(buffer + 4, sizeof(buffer) - 4, "%04X", m_srec_address);
1763 write_size = 8;
1764 break;
1765
1766 case SREC_TYPE_S2:
1767 count += 4;
1768 crc += count;
1769 crc += m_srec_address & 0xff;
1770 crc += (m_srec_address >> 8) & 0xff;
1771 crc += m_srec_address >> 16;
1772 buffer[1] = '2';
1773 sprintf_s(buffer + 2, sizeof(buffer) - 2, "%02X", count);
1774 sprintf_s(buffer + 4, sizeof(buffer) - 4, "%06X", m_srec_address);
1775 write_size = 10;
1776 break;
1777
1778 case SREC_TYPE_S3:
1779 count += 5;
1780 crc += count;
1781 crc += m_srec_address & 0xff;
1782 crc += (m_srec_address >> 8) & 0xff;
1783 crc += (m_srec_address >> 16) & 0xff;
1784 crc += m_srec_address >> 24;
1785 buffer[1] = '3';
1786 sprintf_s(buffer + 2, sizeof(buffer) - 2, "%02X", count);
1787 sprintf_s(buffer + 4, sizeof(buffer) - 4, "%08X", m_srec_address);
1788 write_size = 12;
1789 break;
1790
1791 case SREC_TYPE_S5:
1792 count += 3;
1793 crc += count;
1794 crc += m_srec_record_count & 0xff;
1795 crc += m_srec_record_count >> 8;
1796 buffer[1] = '5';
1797 sprintf_s(buffer + 2, sizeof(buffer) - 2, "%02X", count);
1798 sprintf_s(buffer + 4, sizeof(buffer) - 4, "%04X", m_srec_record_count);
1799 write_size = 8;
1800 break;
1801
1802 case SREC_TYPE_S6:
1803 count += 4;
1804 crc += count;
1805 crc += m_srec_record_count & 0xff;
1806 crc += (m_srec_record_count >> 8) & 0xff;
1807 crc += m_srec_record_count >> 16;
1808 buffer[1] = '6';
1809 sprintf_s(buffer + 2, sizeof(buffer) - 2, "%02X", count);
1810 sprintf_s(buffer + 4, sizeof(buffer) - 4, "%06X", m_srec_record_count);
1811 write_size = 10;
1812 break;
1813 }
1814
1815 for (int index = 0; index < m_srec_data_size; index++)
1816 {
1817 crc += m_srec_data[index];
1818
1819 if (write_size < sizeof(buffer))
1820 {
1821 sprintf_s(buffer + write_size, sizeof(buffer) - write_size, "%02X", m_srec_data[index]);
1822 write_size += 2;
1823 }
1824 }
1825
1826 crc &= 0xff;
1827 crc = (~(UCHAR)crc) & 0xff;
1828
1829 if (write_size < sizeof(buffer))
1830 {
1831 sprintf_s(buffer + write_size, sizeof(buffer) - write_size, "%02X", crc);
1832 write_size += 2;
1833 }
1834
1835 if (write_size + 1 < sizeof(buffer))
1836 {
1837 buffer[write_size++] = '\r';
1838 buffer[write_size++] = '\n';
1839 }
1840
1841 FileWrite(buffer, write_size);//write srecord
1842
1843 if (type != SREC_TYPE_S0)
1844 {
1845 m_srec_address += m_srec_data_size;
1846 m_srec_record_count++;
1847 }
1848 m_srec_data_size = 0;
1849 }
1850
1851 ///////////////////////////////////////////////////////////////////////////////
WriteSRecordData(const void * data_ptr,INT data_size)1852 VOID binary_resource_gen::WriteSRecordData(const void *data_ptr, INT data_size)
1853 {
1854 INT remain_size;
1855 INT written_size;
1856
1857 if (data_size + m_srec_data_size < SREC_MAX_DATA_SIZE)
1858 {
1859 memcpy_s(m_srec_data + m_srec_data_size, SREC_MAX_DATA_SIZE - m_srec_data_size, data_ptr, data_size);
1860 m_srec_data_size += data_size;
1861 }
1862 else
1863 {
1864 written_size = 0;
1865
1866 while (written_size != data_size)
1867 {
1868 if (m_srec_data_size == SREC_MAX_DATA_SIZE)
1869 {
1870 WriteOneSRecord();
1871 }
1872
1873 remain_size = SREC_MAX_DATA_SIZE - m_srec_data_size;
1874
1875 if (data_size - written_size <= remain_size)
1876 {
1877 memcpy_s(m_srec_data + m_srec_data_size, remain_size, (char *)data_ptr + written_size, data_size - written_size);
1878 m_srec_data_size += data_size - written_size;
1879 written_size = data_size;
1880 }
1881 else
1882 {
1883 memcpy_s(m_srec_data + m_srec_data_size, remain_size, (char *)data_ptr + written_size, remain_size);
1884 written_size += remain_size;
1885 m_srec_data_size += remain_size;
1886 }
1887 }
1888 }
1889 }
1890
1891 ///////////////////////////////////////////////////////////////////////////////
WriteSRecordHeader()1892 VOID binary_resource_gen::WriteSRecordHeader()
1893 {
1894 INT type = SREC_TYPE_S0;
1895 const char header[] = "guix_resource_data";
1896
1897 m_srec_data_size = strlen(header);
1898 memcpy_s(m_srec_data, sizeof(m_srec_data), header, m_srec_data_size);
1899
1900 WriteOneSRecord(type);
1901 }
1902
1903 ///////////////////////////////////////////////////////////////////////////////
WriteSRecordEnd()1904 VOID binary_resource_gen::WriteSRecordEnd()
1905 {
1906 INT type;
1907
1908 if (m_srec_record_count < 0xffff)
1909 {
1910 type = SREC_TYPE_S5;
1911 }
1912 else
1913 {
1914 return;
1915 }
1916
1917 WriteOneSRecord(type);
1918 }
1919
1920 ///////////////////////////////////////////////////////////////////////////////
WriteDataOut(const void * lpBuf,UINT nCount)1921 VOID binary_resource_gen::WriteDataOut(const void *lpBuf, UINT nCount)
1922 {
1923 switch (m_file_format)
1924
1925 {
1926 case BINARY_FILE_FORMAT_BIN:
1927 case BINARY_FILE_FORMAT_BIN_STANDALONE:
1928 FileWrite(lpBuf, nCount);
1929 break;
1930
1931 case BINARY_FILE_FORMAT_SREC:
1932 WriteSRecordData(lpBuf, nCount);
1933 break;
1934 }
1935
1936 m_written_size += nCount;
1937 }
1938
1939 ///////////////////////////////////////////////////////////////////////////////
WritePixelmapBlock(res_info * info,USHORT map_id,USHORT output_map_id,USHORT theme_id,int frame_id)1940 void binary_resource_gen::WritePixelmapBlock(res_info *info, USHORT map_id, USHORT output_map_id, USHORT theme_id, int frame_id)
1941 {
1942 GX_PIXELMAP *map = info->GetPixelmap(frame_id);
1943
1944 if (!map)
1945 {
1946 return;
1947 }
1948
1949 GX_PIXELMAP_HEADER header;
1950 int refer_theme = -1;
1951
1952 if (m_file_format == BINARY_FILE_FORMAT_BIN_STANDALONE)
1953 {
1954 CString filename = RemoveFileExtension(m_outfile->GetFileName());
1955 filename.MakeUpper();
1956
1957 file_info* finfo = FindFileInfo(&m_file_dictionary, filename);
1958 if (!finfo)
1959 {
1960 finfo = m_file_dictionary.GetAt(0);
1961 }
1962
1963 output_map_id = finfo->write_res_index++;
1964 }
1965
1966 memset(&header, 0, sizeof(GX_PIXELMAP_HEADER));
1967
1968 header.gx_pixelmap_header_magic_number = GX_MAGIC_NUMBER;
1969 header.gx_pixelmap_header_index = output_map_id;
1970 header.gx_pixelmap_header_version_major = map->gx_pixelmap_version_major;
1971 header.gx_pixelmap_header_version_minor = map->gx_pixelmap_version_minor;
1972 header.gx_pixelmap_header_flags = map->gx_pixelmap_flags;
1973 header.gx_pixelmap_header_format = map->gx_pixelmap_format;
1974 header.gx_pixelmap_header_transparent_color = map->gx_pixelmap_transparent_color;
1975 header.gx_pixelmap_header_width = map->gx_pixelmap_width;
1976 header.gx_pixelmap_header_height = map->gx_pixelmap_height;
1977
1978 if (project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX && map_id)
1979 {
1980 refer_theme = FindResourceReferenceTheme(info, theme_id);
1981
1982 if (refer_theme >= 0)
1983 {
1984 header.gx_pixelmap_header_data_offset = GetPixelmapDataOffset(map_id, frame_id, refer_theme);
1985
1986 // write pixelmap header
1987 WritePixelmapHeader(&header);
1988
1989 return;
1990 }
1991 }
1992
1993 int data_output_pos = m_written_size + GetPixelmapHeaderSize();
1994 int padding = 0;
1995
1996 if (project_lib_version() >= GX_VERSION_BINRES_DATA_ALIGNMENT_FIX)
1997 {
1998 if (data_output_pos & 0x03)
1999 {
2000 // 32bit alignment
2001 padding = 4 - (data_output_pos & 0x03);
2002 }
2003 }
2004 else
2005 {
2006 switch (map->gx_pixelmap_format)
2007 {
2008 case GX_COLOR_FORMAT_24XRGB:
2009 case GX_COLOR_FORMAT_24BGRX:
2010 case GX_COLOR_FORMAT_32ARGB:
2011 case GX_COLOR_FORMAT_32RGBA:
2012 case GX_COLOR_FORMAT_32ABGR:
2013 case GX_COLOR_FORMAT_32BGRA:
2014 if (data_output_pos & 0x03)
2015 {
2016 // 32bit alignment
2017 padding = (data_output_pos & 0x03);
2018 }
2019 break;
2020 case GX_COLOR_FORMAT_565RGB:
2021 case GX_COLOR_FORMAT_565BGR:
2022 case GX_COLOR_FORMAT_4444ARGB:
2023 case GX_COLOR_FORMAT_4444BGRA:
2024 case GX_COLOR_FORMAT_5551BGRX:
2025 case GX_COLOR_FORMAT_1555XRGB:
2026 if (data_output_pos & 0x01)
2027 {
2028 // 16bit alignment
2029 padding = (data_output_pos & 0x01);
2030 }
2031 break;
2032
2033 default:
2034 // Do nothing
2035 break;
2036 }
2037 }
2038
2039 if (info->raw)
2040 {
2041 //write raw image
2042 CString path;
2043 UCHAR buffer[1024];
2044 long file_size;
2045 long total_bytes_written;
2046 int chunk_size;
2047
2048 path = MakeAbsolutePathname(info->pathinfo);
2049 FILE *file = _tfopen(path.GetBuffer(), _T("rb"));
2050
2051 if (!file)
2052 {
2053 return;
2054 }
2055
2056 fseek(file, 0, SEEK_END);
2057 file_size = ftell(file);
2058
2059 header.gx_pixelmap_header_flags |= GX_PIXELMAP_RAW_FORMAT;
2060 header.gx_pixelmap_header_map_size = file_size;
2061 header.gx_pixelmap_header_aux_data_size = 0;
2062 header.gx_pixelmap_header_data_size = file_size;
2063
2064 // write pixelmap header
2065 WritePixelmapHeader(&header);
2066
2067 // Padding for alignment
2068 if (padding)
2069 {
2070 WriteDataOut(filling_string, padding);
2071 }
2072
2073 fseek(file, 0, SEEK_SET);
2074
2075 total_bytes_written = 0;
2076
2077 while (total_bytes_written < file_size)
2078 {
2079 chunk_size = fread(buffer, 1, 1024, file);
2080
2081 WriteDataOut(buffer, chunk_size);
2082 total_bytes_written += chunk_size;
2083 }
2084
2085 fclose(file);
2086 }
2087 else
2088 {
2089 GX_PIXELMAP* rotated_map = GX_NULL;
2090
2091 if (IsRotatedResourceSupported(m_project, m_display))
2092 {
2093 rotated_map = m_rotated_pixelmaps[theme_id].GetAt(output_map_id - 1);
2094
2095 if (!rotated_map)
2096 {
2097 rotated_map = RotatePixelmap(info, theme_id, map, frame_id);
2098 m_rotated_pixelmaps[theme_id].SetAt(output_map_id - 1, rotated_map);
2099 }
2100 map = rotated_map;
2101 }
2102
2103 header.gx_pixelmap_header_flags = map->gx_pixelmap_flags;
2104 header.gx_pixelmap_header_map_size = map->gx_pixelmap_data_size;
2105 header.gx_pixelmap_header_aux_data_size = map->gx_pixelmap_aux_data_size;
2106 header.gx_pixelmap_header_data_size = map->gx_pixelmap_data_size + map->gx_pixelmap_aux_data_size;
2107
2108 // write pixelmap header
2109 WritePixelmapHeader(&header);
2110
2111 // write image as guix format
2112 if (map->gx_pixelmap_data)
2113 {
2114 // Padding for alignment
2115 if (padding)
2116 {
2117 WriteDataOut(filling_string, padding);
2118 }
2119
2120 // Write pixelmap data
2121 if (m_big_endian)
2122 {
2123 switch (map->gx_pixelmap_format)
2124 {
2125 case GX_COLOR_FORMAT_24XRGB:
2126 case GX_COLOR_FORMAT_24BGRX:
2127 case GX_COLOR_FORMAT_32ARGB:
2128 case GX_COLOR_FORMAT_32RGBA:
2129 case GX_COLOR_FORMAT_32ABGR:
2130 case GX_COLOR_FORMAT_32BGRA:
2131 WriteBigEndianUintData(map);
2132 break;
2133 case GX_COLOR_FORMAT_565RGB:
2134 case GX_COLOR_FORMAT_565BGR:
2135 case GX_COLOR_FORMAT_4444ARGB:
2136 case GX_COLOR_FORMAT_4444BGRA:
2137 case GX_COLOR_FORMAT_5551BGRX:
2138 case GX_COLOR_FORMAT_1555XRGB:
2139 if (m_big_endian &&
2140 (map->gx_pixelmap_flags & GX_PIXELMAP_COMPRESSED) &&
2141 (map->gx_pixelmap_flags & GX_PIXELMAP_ALPHA))
2142 {
2143 WriteBigEndianCompressedUshortData(map);
2144 }
2145 else
2146 {
2147 WriteBigEndianUshortData(map);
2148 }
2149 break;
2150
2151 case GX_COLOR_FORMAT_8BIT_PACKED_PIXEL:
2152 if ((map->gx_pixelmap_flags & GX_PIXELMAP_COMPRESSED) &&
2153 (map->gx_pixelmap_flags & GX_PIXELMAP_ALPHA))
2154 {
2155 WriteBigEndianUshortData(map);
2156 }
2157 else
2158 {
2159 WriteDataOut(map->gx_pixelmap_data, map->gx_pixelmap_data_size);
2160 }
2161 break;
2162 default:
2163 WriteDataOut(map->gx_pixelmap_data, map->gx_pixelmap_data_size);
2164 break;
2165 }
2166 }
2167 else
2168 {
2169 WriteDataOut(map->gx_pixelmap_data, map->gx_pixelmap_data_size);
2170 }
2171 }
2172
2173 if (map->gx_pixelmap_aux_data)
2174 {
2175 WriteDataOut(map->gx_pixelmap_aux_data, map->gx_pixelmap_aux_data_size);
2176 }
2177 }
2178 }
2179
2180 ///////////////////////////////////////////////////////////////////////////////
WriteStringBlock()2181 void binary_resource_gen::WriteStringBlock()
2182 {
2183 string_table *pTable = m_project->mDisplays[m_display].stable;
2184
2185 GX_STRING_HEADER header;
2186 header.gx_string_header_magic_number = GX_MAGIC_NUMBER;
2187 header.gx_string_header_language_count = GetEnabledLanguageCount();
2188 header.gx_string_header_string_count = pTable->CountGeneratedStrings();
2189 header.gx_string_header_data_size = GetStringDataSize();
2190
2191 // Write string header
2192 WriteStringHeader(&header);
2193
2194 BOOL enabled;
2195 CCommandInfo *pCmd = GetCmdInfo();
2196
2197 // write string data
2198 for (int language_id = 0; language_id < m_project->mHeader.num_languages; language_id++)
2199 {
2200 if (pCmd->IsNoGui())
2201 {
2202 enabled = pCmd->IsLanguageEnabled(m_project->mHeader.languages[language_id].name);
2203 }
2204 else
2205 {
2206 enabled = m_project->mDisplays[m_display].gen_string_table[language_id];
2207 }
2208
2209 if (enabled)
2210 {
2211 WriteStringData(language_id);
2212 }
2213 }
2214 }
2215
2216 ///////////////////////////////////////////////////////////////////////////////
WriteStringData(USHORT language_id)2217 void binary_resource_gen::WriteStringData(USHORT language_id)
2218 {
2219 string_table *pTable = m_project->mDisplays[m_display].stable;
2220 int num_strings = pTable->CountStrings();
2221 CString val;
2222 char end_of_string[] = "";
2223
2224 GX_LANGUAGE_HEADER header;
2225 header.gx_language_header_magic_number = GX_MAGIC_NUMBER;
2226 header.gx_language_header_index = language_id;
2227 memset(header.gx_language_header_name, 0, GX_LANGUAGE_HEADER_NAME_SIZE);
2228 strcpy_s((char *)header.gx_language_header_name, GX_LANGUAGE_HEADER_NAME_SIZE, CT2A(m_project->mHeader.languages[language_id].name));
2229 header.gx_language_header_data_size = GetStringDataSize(language_id);
2230
2231 // Write language header
2232 WriteLanguageHeader(&header);
2233
2234 CString id_name;
2235 GX_STRING utf8str;
2236 CArray<widget_info*> *info_list;
2237 widget_info* info;
2238 int reference_count;
2239
2240 // Write strings
2241 for (int string_id = 1; string_id < num_strings; string_id++)
2242 {
2243 id_name = pTable->GetResourceIdName(string_id);
2244 val = pTable->GetString(id_name, language_id);
2245
2246 if (val.IsEmpty())
2247 {
2248 utf8str.gx_string_ptr = end_of_string;
2249 utf8str.gx_string_length = 0;
2250 WriteOneStringData(&utf8str);
2251 }
2252 else
2253 {
2254
2255 info_list = pTable->GetMLViewReferenceWidgetInfoList(id_name);
2256
2257 if (info_list)
2258 {
2259 reference_count = info_list->GetCount();
2260 }
2261 else
2262 {
2263 reference_count = 1;
2264 }
2265
2266 info = NULL;
2267
2268 for (int index = 0; index < reference_count; index++)
2269 {
2270 if (info_list)
2271 {
2272 info = info_list->GetAt(index);
2273 }
2274
2275 MakeUtf8String(m_project, val, language_id, &utf8str, m_display, TRUE, info);
2276 WriteOneStringData(&utf8str);
2277 delete[] utf8str.gx_string_ptr;
2278 utf8str.gx_string_length = 0;
2279 }
2280 }
2281 }
2282 }
2283
2284 ///////////////////////////////////////////////////////////////////////////////
WriteOneStringData(GX_STRING * string)2285 void binary_resource_gen::WriteOneStringData(GX_STRING *string)
2286 {
2287 USHORT write_ushort;
2288
2289 if (project_lib_version() >= GX_VERSION_STRING_LENGTH_FIX)
2290 {
2291 // Write out string length
2292 write_ushort = string->gx_string_length;
2293 write_ushort = SwapUshort(write_ushort);
2294 WriteDataOut(&write_ushort, sizeof(USHORT));
2295 }
2296
2297 // Write out string
2298 WriteDataOut(string->gx_string_ptr, string->gx_string_length + 1);
2299 }
2300
2301 ///////////////////////////////////////////////////////////////////////////////
GetEnabledThemeCount()2302 USHORT binary_resource_gen::GetEnabledThemeCount()
2303 {
2304 if (!m_project)
2305 {
2306 return 0;
2307 }
2308
2309 USHORT count = 0;
2310 BOOL enabled;
2311 CString theme_name;
2312
2313 CCommandInfo *pCmd = GetCmdInfo();
2314
2315 for (int theme = 0; theme < m_project->mDisplays[m_display].num_themes; theme++)
2316 {
2317 if (pCmd->IsNoGui())
2318 {
2319 theme_name = m_project->mDisplays[m_display].themes[theme].theme_name;
2320 enabled = pCmd->IsThemeEnabled(theme_name);
2321 }
2322 else
2323 {
2324 enabled = m_project->mDisplays[m_display].themes[theme].enabled;
2325 }
2326
2327 if (enabled)
2328 {
2329 count++;
2330 }
2331 }
2332
2333 return count;
2334 }
2335
2336 ///////////////////////////////////////////////////////////////////////////////
GetEnabledLanguageCount()2337 USHORT binary_resource_gen::GetEnabledLanguageCount()
2338 {
2339 if (!m_project)
2340 {
2341 return 0;
2342 }
2343
2344 USHORT count = 0;
2345 BOOL enabled;
2346 CCommandInfo *pCmd = GetCmdInfo();
2347 CString lang_name;
2348
2349 for (int language = 0; language < m_project->mHeader.num_languages; language++)
2350 {
2351 if (pCmd->IsNoGui())
2352 {
2353 lang_name = m_project->mHeader.languages[language].name;
2354 enabled = pCmd->IsLanguageEnabled(lang_name);
2355 }
2356 else
2357 {
2358 enabled = m_project->mDisplays[m_display].gen_string_table[language];
2359 }
2360
2361 if (enabled)
2362 {
2363 count++;
2364 }
2365 }
2366
2367 return count;
2368 }
2369
2370 ///////////////////////////////////////////////////////////////////////////////
GetColorCount(USHORT theme_id)2371 USHORT binary_resource_gen::GetColorCount(USHORT theme_id)
2372 {
2373 int color_count = 0;
2374
2375 CCommandInfo *pCmd = GetCmdInfo();
2376
2377 if (pCmd->IsNoGui() || m_project->mDisplays[m_display].themes[theme_id].gen_color_table)
2378 {
2379 color_count = m_project->CountResources(m_display, RES_TYPE_COLOR);
2380 }
2381
2382 return color_count;
2383 }
2384
2385 ///////////////////////////////////////////////////////////////////////////////
GetFontCount(USHORT theme_id)2386 USHORT binary_resource_gen::GetFontCount(USHORT theme_id)
2387 {
2388 int font_count = 0;
2389
2390 CCommandInfo *pCmd = GetCmdInfo();
2391
2392 if (pCmd->IsNoGui() || m_project->mDisplays[m_display].themes[theme_id].gen_font_table)
2393 {
2394 font_count = m_project->CountResources(m_display, RES_TYPE_FONT);
2395 }
2396 return font_count;
2397 }
2398
2399 ///////////////////////////////////////////////////////////////////////////////
GetPageCount(res_info * info,USHORT theme_id,USHORT font_id)2400 USHORT binary_resource_gen::GetPageCount(res_info *info, USHORT theme_id, USHORT font_id)
2401 {
2402 const GX_FONT *font_page;
2403 GX_FONT *head_page;
2404 int page_index;
2405
2406 if (info->is_default && info->pathinfo.pathname.IsEmpty() &&
2407 !IsRotatedResourceSupported(m_project, m_display))
2408 {
2409 return 0;
2410 }
2411
2412 head_page = GetPageHead(info, theme_id, font_id);
2413
2414 //write font data
2415 font_page = head_page;
2416 page_index = 0;
2417 while (font_page)
2418 {
2419 page_index++;
2420 font_page = font_page->gx_font_next_page;
2421 }
2422
2423 return page_index;
2424 }
2425
2426 ///////////////////////////////////////////////////////////////////////////////
GetPixelmapCount(USHORT theme_id)2427 USHORT binary_resource_gen::GetPixelmapCount(USHORT theme_id)
2428 {
2429 int pixlemap_count = 0;
2430
2431 CCommandInfo *pCmd = GetCmdInfo();
2432
2433 if (pCmd->IsNoGui() || m_project->mDisplays[m_display].themes[theme_id].gen_pixelmap_table)
2434 {
2435 INT pixelmap_id;
2436
2437 for (pixelmap_id = 1; pixelmap_id < m_pixelmap_dictionary.GetCount(); pixelmap_id++)
2438 {
2439 res_info *info = m_project->FindResource(m_display, theme_id, RES_TYPE_PIXELMAP, m_pixelmap_dictionary.GetAt(pixelmap_id));
2440
2441 if (info)
2442 {
2443 if ((info->enabled) || (IsSystemPixelmap(pixelmap_id)))
2444 {
2445 pixlemap_count += info->GetPixelmapFrameCount();
2446 }
2447 }
2448 }
2449 }
2450
2451 return pixlemap_count;
2452 }
2453
2454 ///////////////////////////////////////////////////////////////////////////////
GetFontHeaderSize()2455 INT binary_resource_gen::GetFontHeaderSize()
2456 {
2457 if (project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX)
2458 {
2459 // new member "data_offset" is added
2460 return GX_FONT_HEADER_SIZE;
2461 }
2462 else
2463 {
2464 return GX_FONT_HEADER_SIZE - sizeof(ULONG);
2465 }
2466 }
2467
2468 ///////////////////////////////////////////////////////////////////////////////
GetGlyphHeaderSize()2469 INT binary_resource_gen::GetGlyphHeaderSize()
2470 {
2471 if (project_lib_version() >= GX_VERSION_BINRES_FONT_ALIGNMENT_FIX)
2472 {
2473 return GX_GLYPH_HEADER_SIZE;
2474 }
2475 else
2476 {
2477 return GX_GLYPH_HEADER_SIZE - sizeof(ULONG);
2478 }
2479 }
2480
2481 ///////////////////////////////////////////////////////////////////////////////
GetKerningGlyphHeaderSize()2482 INT binary_resource_gen::GetKerningGlyphHeaderSize()
2483 {
2484 if (project_lib_version() >= GX_VERSION_BINRES_FONT_ALIGNMENT_FIX)
2485 {
2486 return GX_KERNING_GLYPH_HEADER_SIZE;
2487 }
2488 else
2489 {
2490 return GX_KERNING_GLYPH_HEADER_SIZE - sizeof(ULONG);
2491 }
2492 }
2493
2494 ///////////////////////////////////////////////////////////////////////////////
GetPixelmapHeaderSize()2495 INT binary_resource_gen::GetPixelmapHeaderSize()
2496 {
2497 if (project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX)
2498 {
2499 // new member "data_offset" is added
2500 return GX_PIXELMAP_HEADER_SIZE;
2501 }
2502 else
2503 {
2504 return GX_PIXELMAP_HEADER_SIZE - sizeof(ULONG);
2505 }
2506 }
2507
2508 ///////////////////////////////////////////////////////////////////////////////
GetThemeDataSize(SHORT theme_count)2509 ULONG binary_resource_gen::GetThemeDataSize(SHORT theme_count)
2510 {
2511 ULONG size = 0;
2512 ULONG data_size = 0;
2513 ULONG written_size = GetResourceHeaderSize();
2514
2515 CCommandInfo *pCmd = GetCmdInfo();
2516 BOOL enabled;
2517
2518 if (theme_count < 0)
2519 {
2520 theme_count = m_project->mDisplays[m_display].num_themes;
2521 }
2522
2523 for (int theme = 0; theme < theme_count; theme++)
2524 {
2525 if (pCmd->IsNoGui())
2526 {
2527 enabled = pCmd->IsThemeEnabled(m_project->mDisplays[m_display].themes[theme].theme_name);
2528 }
2529 else
2530 {
2531 enabled = m_project->mDisplays[m_display].themes[theme].enabled;
2532 }
2533
2534 if (enabled)
2535 {
2536 size = GetThemeHeaderSize();
2537 written_size += size;
2538 data_size += size;
2539
2540 size = GetThemeDataSize(written_size, theme);
2541 written_size += size;
2542 data_size += size;
2543 }
2544 }
2545
2546 return data_size;
2547 }
2548
2549 ///////////////////////////////////////////////////////////////////////////////
GetThemeDataSize(ULONG written_size,USHORT theme_id)2550 ULONG binary_resource_gen::GetThemeDataSize(ULONG written_size, USHORT theme_id)
2551 {
2552 int theme_data_size = 0;
2553 int data_size;
2554
2555 //Calcualte color data size
2556 theme_data_size += GetColorBlockSize(theme_id);
2557
2558 //Calcualte palette table size
2559 theme_data_size += GetPaletteBlockSize(theme_id);
2560
2561 written_size += theme_data_size;
2562
2563 //Calculate font data size
2564 data_size = GetFontBlockSize(written_size, theme_id, -1);
2565 written_size += data_size;
2566 theme_data_size += data_size;
2567
2568 //Calculate pixelmap data size
2569 theme_data_size += GetPixelmapBlockSize(written_size, theme_id, -1, -1);
2570
2571 return theme_data_size;
2572 }
2573
2574 ///////////////////////////////////////////////////////////////////////////////
GetPaletteBlockSize(USHORT theme_id)2575 ULONG binary_resource_gen::GetPaletteBlockSize(USHORT theme_id)
2576 {
2577 ULONG data_size = 0;
2578
2579 if (m_project->mDisplays[m_display].themes[theme_id].palette)
2580 {
2581 INT color_count = m_project->mDisplays[m_display].themes[theme_id].palette_total_size;
2582
2583 if (color_count)
2584 {
2585 data_size += GetPaletteHeaderSize();
2586 data_size += color_count * sizeof(GX_COLOR);
2587 }
2588 }
2589
2590 return data_size;
2591 }
2592
2593 ///////////////////////////////////////////////////////////////////////////////
GetColorBlockSize(USHORT theme_id)2594 ULONG binary_resource_gen::GetColorBlockSize(USHORT theme_id)
2595 {
2596 ULONG data_size = 0;
2597
2598 CCommandInfo *pCmd = GetCmdInfo();
2599
2600 if (pCmd->IsNoGui() || m_project->mDisplays[m_display].themes[theme_id].gen_color_table)
2601 {
2602 INT color_count = GetColorCount(theme_id);
2603
2604 if (color_count)
2605 {
2606 data_size += GetColorHeaderSize();
2607 data_size += color_count * sizeof(GX_COLOR);
2608 }
2609 }
2610
2611 return data_size;
2612 }
2613
2614 ///////////////////////////////////////////////////////////////////////////////
GetFontBlockSize(ULONG written_size,USHORT theme_id,SHORT font_count)2615 ULONG binary_resource_gen::GetFontBlockSize(ULONG written_size, USHORT theme_id, SHORT font_count)
2616 {
2617 ULONG data_size = 0;
2618 ULONG size;
2619 int reference_theme = -1;
2620
2621 CCommandInfo *pCmd = GetCmdInfo();
2622
2623 if (font_count < 0)
2624 {
2625 font_count = m_project->CountResources(m_display, RES_TYPE_FONT);
2626 }
2627
2628 if (pCmd->IsNoGui() || m_project->mDisplays[m_display].themes[theme_id].gen_font_table)
2629 {
2630 int font_id = 0;
2631
2632 for (font_id = 0; font_id < font_count; font_id++)
2633 {
2634 res_info *info = m_project->FindResource(m_display, theme_id, RES_TYPE_FONT, font_id);
2635
2636 if (info)
2637 {
2638 if (project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX)
2639 {
2640 reference_theme = FindResourceReferenceTheme(info, theme_id);
2641 }
2642
2643 data_size += GetFontHeaderSize();
2644 written_size += GetFontHeaderSize();
2645
2646 /* This font is duplicate with the font in "reference_theme",
2647 don't need to generate the same font data. */
2648 if (reference_theme < 0)
2649 {
2650 size = GetFontDataSize(written_size, info, theme_id, font_id);
2651 data_size += size;
2652 written_size += size;
2653 }
2654 }
2655 }
2656 }
2657
2658 return data_size;
2659 }
2660
2661 ///////////////////////////////////////////////////////////////////////////////
GetOnePixelmapDataSize(ULONG written_size,res_info * info,USHORT theme_id,INT frame_id,USHORT outmap_id)2662 ULONG binary_resource_gen::GetOnePixelmapDataSize(ULONG written_size, res_info *info, USHORT theme_id, INT frame_id, USHORT outmap_id)
2663 {
2664 ULONG data_size = 0;
2665 INT padding;
2666
2667 GX_PIXELMAP *map = info->GetPixelmap(frame_id);
2668
2669 if (project_lib_version() >= GX_VERSION_BINRES_DATA_ALIGNMENT_FIX)
2670 {
2671 if (written_size & 0x03)
2672 {
2673 padding = (4 - (written_size & 0x03));
2674 data_size += padding;
2675 written_size += padding;
2676 }
2677 }
2678 else
2679 {
2680
2681 switch (map->gx_pixelmap_format)
2682 {
2683 case GX_COLOR_FORMAT_24XRGB:
2684 case GX_COLOR_FORMAT_24BGRX:
2685 case GX_COLOR_FORMAT_32ARGB:
2686 case GX_COLOR_FORMAT_32RGBA:
2687 case GX_COLOR_FORMAT_32ABGR:
2688 case GX_COLOR_FORMAT_32BGRA:
2689 if (written_size & 0x03)
2690 {
2691 data_size += written_size & 0x03;
2692 written_size += written_size & 0x03;
2693 }
2694 break;
2695 case GX_COLOR_FORMAT_565RGB:
2696 case GX_COLOR_FORMAT_565BGR:
2697 case GX_COLOR_FORMAT_4444ARGB:
2698 case GX_COLOR_FORMAT_4444BGRA:
2699 case GX_COLOR_FORMAT_5551BGRX:
2700 case GX_COLOR_FORMAT_1555XRGB:
2701 if (written_size & 0x01)
2702 {
2703 //16bit alignment
2704 data_size += written_size & 0x01;
2705 written_size += written_size & 0x01;
2706 }
2707 }
2708 }
2709
2710 if (info->raw)
2711 {
2712 CString path = MakeAbsolutePathname(info->pathinfo);
2713 FILE* file = _tfopen(path.GetBuffer(), _T("rb"));
2714
2715 if (!file)
2716 {
2717 return 0;
2718 }
2719
2720 fseek(file, 0, SEEK_END);
2721 data_size += ftell(file);
2722 written_size += ftell(file);
2723 }
2724 else
2725 {
2726 GX_PIXELMAP* rotated_map = GX_NULL;
2727
2728 if (IsRotatedResourceSupported(m_project, m_display))
2729 {
2730 rotated_map = m_rotated_pixelmaps[theme_id].GetAt(outmap_id - 1);
2731
2732 if (!rotated_map)
2733 {
2734 rotated_map = RotatePixelmap(info, theme_id, map, frame_id);
2735 m_rotated_pixelmaps[theme_id].SetAt(outmap_id - 1, rotated_map);
2736 }
2737
2738 map = rotated_map;
2739 }
2740
2741 data_size += map->gx_pixelmap_data_size;
2742 data_size += map->gx_pixelmap_aux_data_size;
2743 written_size += map->gx_pixelmap_data_size;
2744 written_size += map->gx_pixelmap_aux_data_size;
2745 }
2746
2747 return data_size;
2748 }
2749
2750 ///////////////////////////////////////////////////////////////////////////////
GetPixelmapBlockSize(ULONG written_size,USHORT theme_id,SHORT map_id,SHORT frame_id)2751 ULONG binary_resource_gen::GetPixelmapBlockSize(ULONG written_size, USHORT theme_id, SHORT map_id, SHORT frame_id)
2752 {
2753 ULONG data_size = 0;
2754 ULONG size;
2755 int reference_theme = -1;
2756 int frame_count;
2757 int index;
2758
2759 CCommandInfo *pCmd = GetCmdInfo();
2760
2761 if (map_id < 0)
2762 {
2763 map_id = m_pixelmap_dictionary.GetCount() - 1;
2764 }
2765
2766 if (pCmd->IsNoGui() || m_project->mDisplays[m_display].themes[theme_id].gen_pixelmap_table)
2767 {
2768 int pixelmap_id;
2769 int output_pixelmap_id = 1;
2770
2771 for (pixelmap_id = 1; pixelmap_id <= map_id; pixelmap_id++)
2772 {
2773 res_info *info = m_project->FindResource(m_display, theme_id, RES_TYPE_PIXELMAP, m_pixelmap_dictionary.GetAt(pixelmap_id));
2774
2775 if (info && info->GetPixelmapFrameCount() && (info->enabled) && (info->parent->enabled))
2776 {
2777 if (project_lib_version() >= GX_VERSION_DUPLICATE_BINRES_DATA_FIX)
2778 {
2779 reference_theme = FindResourceReferenceTheme(info, theme_id);
2780 }
2781
2782 if ((pixelmap_id < map_id) || (frame_id < 0))
2783 {
2784 frame_count = info->GetPixelmapFrameCount();
2785 }
2786 else
2787 {
2788 frame_count = frame_id;
2789 }
2790
2791 for (index = 0; index < frame_count; index++)
2792 {
2793 data_size += GetPixelmapHeaderSize();
2794 written_size += GetPixelmapHeaderSize();
2795
2796 if (reference_theme < 0)
2797 {
2798 size = GetOnePixelmapDataSize(written_size, info, theme_id, index, output_pixelmap_id);
2799 data_size += size;
2800 written_size += size;
2801 }
2802 output_pixelmap_id++;
2803 }
2804 }
2805 else if(IsSystemPixelmap(pixelmap_id))
2806 {
2807 output_pixelmap_id++;
2808 }
2809 }
2810 }
2811
2812 return data_size;
2813 }
2814
2815 ///////////////////////////////////////////////////////////////////////////////
InitFontSizeStorage(int display)2816 void binary_resource_gen::InitFontSizeStorage(int display)
2817 {
2818 int font_count = m_project->CountResources(display, RES_TYPE_FONT);
2819 for (int index = 0; index < m_project->mDisplays[display].num_themes; index++)
2820 {
2821 m_font_data_size[index] = new INT[font_count];
2822 memset(m_font_data_size[index], 0, sizeof(INT) * font_count);
2823 }
2824 }
2825
2826 ///////////////////////////////////////////////////////////////////////////////
DeleteFontSizeStorage(int display)2827 void binary_resource_gen::DeleteFontSizeStorage(int display)
2828 {
2829 for (int index = 0; index < m_project->mDisplays[display].num_themes; index++)
2830 {
2831 delete m_font_data_size[index];
2832 }
2833 }
2834
2835 ///////////////////////////////////////////////////////////////////////////////
GetFontDataSize(ULONG written_size,res_info * info,USHORT theme_id,USHORT font_id)2836 ULONG binary_resource_gen::GetFontDataSize(ULONG written_size, res_info *info, USHORT theme_id, USHORT font_id)
2837 {
2838 if (m_font_data_size[theme_id][font_id])
2839 {
2840 return m_font_data_size[theme_id][font_id];
2841 }
2842
2843 if (info->is_default && info->pathinfo.pathname.IsEmpty() &&
2844 !IsRotatedResourceSupported(m_project, m_display))
2845 {
2846 // Default font.
2847 return 0;
2848 }
2849
2850 ULONG data_size = 0;
2851 ULONG size;
2852 GX_FONT* head_page = GetPageHead(info, theme_id, font_id);
2853
2854 const GX_FONT *font_page = head_page;
2855 while (font_page)
2856 {
2857 data_size += GetPageHeaderSize();
2858 written_size += GetPageHeaderSize();
2859
2860 size = GetPageDataSize(written_size, font_page);
2861 data_size += size;
2862 written_size += size;
2863
2864 font_page = font_page->gx_font_next_page;
2865 }
2866
2867 m_font_data_size[theme_id][font_id] = data_size;
2868
2869 return data_size;
2870 }
2871
2872 ///////////////////////////////////////////////////////////////////////////////
GetFontDataOffset(USHORT font_id,USHORT theme_id)2873 ULONG binary_resource_gen::GetFontDataOffset(USHORT font_id, USHORT theme_id)
2874 {
2875 ULONG data_offset;
2876
2877 data_offset = GetResourceHeaderSize();
2878 data_offset += GetThemeDataSize(theme_id);
2879
2880 data_offset += GetThemeHeaderSize();
2881
2882 //Calculate color block size
2883 data_offset += GetColorBlockSize(theme_id);
2884
2885 //Calcualte palette table size
2886 data_offset += GetPaletteBlockSize(theme_id);
2887
2888 if (font_id)
2889 {
2890 data_offset += GetFontBlockSize(data_offset, theme_id, font_id);
2891 }
2892
2893 return data_offset;
2894 }
2895
2896 ///////////////////////////////////////////////////////////////////////////////
GetPixelmapDataOffset(USHORT map_id,USHORT frame_id,USHORT theme_id)2897 ULONG binary_resource_gen::GetPixelmapDataOffset(USHORT map_id, USHORT frame_id, USHORT theme_id)
2898 {
2899 ULONG data_offset;
2900
2901 data_offset = GetResourceHeaderSize();
2902 data_offset += GetThemeDataSize(theme_id);
2903
2904 data_offset += GetThemeHeaderSize();
2905
2906 //Calculate color block size
2907 data_offset += GetColorBlockSize(theme_id);
2908
2909 //Calcualte palette block size
2910 data_offset += GetPaletteBlockSize(theme_id);
2911
2912 // Calcualte font block size
2913 data_offset += GetFontBlockSize(data_offset, theme_id, -1);
2914
2915 if (map_id > 1)
2916 {
2917 data_offset += GetPixelmapBlockSize(data_offset, theme_id, map_id, frame_id);
2918 }
2919
2920 return data_offset;
2921 }
2922
2923 ///////////////////////////////////////////////////////////////////////////////
GetPageDataSize(ULONG written_size,const GX_FONT * font)2924 ULONG binary_resource_gen::GetPageDataSize(ULONG written_size, const GX_FONT *font)
2925 {
2926 if (!font)
2927 {
2928 return 0;
2929 }
2930
2931 GX_CHAR_CODE charval;
2932 ULONG data_size = 0;
2933 ULONG size;
2934
2935 if (font -> gx_font_format & GX_FONT_FORMAT_KERNING)
2936 {
2937 for (charval = font->gx_font_first_glyph; charval <= font->gx_font_last_glyph; charval++)
2938 {
2939 data_size += GetKerningGlyphHeaderSize();
2940 written_size += GetKerningGlyphHeaderSize();
2941
2942 size = GetGlyphDataSize(written_size, font, charval - font->gx_font_first_glyph);
2943 data_size += size;
2944 written_size += size;
2945
2946 size = GetGlyphKerningTableSize(font, charval - font->gx_font_first_glyph);
2947 data_size += size;
2948 written_size += size;
2949 }
2950 }
2951 else
2952 {
2953 for (charval = font->gx_font_first_glyph; charval <= font->gx_font_last_glyph; charval++)
2954 {
2955 data_size += GetGlyphHeaderSize();
2956 written_size += GetGlyphHeaderSize();
2957
2958 size = GetGlyphDataSize(written_size, font, charval - font->gx_font_first_glyph);
2959 data_size += size;
2960 written_size += size;
2961 }
2962 }
2963
2964 return data_size;
2965 }
2966
2967 ///////////////////////////////////////////////////////////////////////////////
GetGlyphKerningTableSize(const GX_FONT * font,INT glyph_index)2968 USHORT binary_resource_gen::GetGlyphKerningTableSize(const GX_FONT *font, INT glyph_index)
2969 {
2970 USHORT table_size = 0;
2971 studiox_project *pProject = GetOpenProject();
2972
2973 if (pProject)
2974 {
2975 GX_CONST GX_KERNING_GLYPH *glyph = &font->gx_font_glyphs.gx_font_kerning_glyphs[glyph_index];
2976 if (glyph->gx_kerning_table)
2977 {
2978 INT pair_counts = *(glyph->gx_kerning_table);
2979 table_size = 1 + pair_counts * (sizeof(GX_UBYTE) + sizeof(GX_CHAR));
2980 }
2981 }
2982
2983 return table_size;
2984 }
2985
2986 ///////////////////////////////////////////////////////////////////////////////
GetGlyphDataSize(ULONG written_size,const GX_FONT * font,INT glyph_index)2987 ULONG binary_resource_gen::GetGlyphDataSize(ULONG written_size, const GX_FONT *font, INT glyph_index)
2988 {
2989 ULONG data_size = 0;
2990 studiox_project *pProject = GetOpenProject();
2991
2992 if (pProject)
2993 {
2994 if (font->gx_font_format & GX_FONT_FORMAT_COMPRESSED)
2995 {
2996 GX_CONST GX_COMPRESSED_GLYPH *glyph = &font->gx_font_glyphs.gx_font_compressed_glyphs[glyph_index];
2997
2998 if (glyph->gx_glyph_map)
2999 {
3000 if (IsRotatedResourceSupported(m_project, m_display))
3001 {
3002 UCHAR* rotated_data;
3003 int mapsize;
3004 RotateGlyphData((GX_GLYPH *)glyph, font->gx_font_format, &rotated_data, &mapsize);
3005 if (rotated_data)
3006 {
3007 delete rotated_data;
3008 }
3009 data_size = mapsize & 0x7fff;
3010 }
3011 else
3012 {
3013 data_size = glyph->gx_glyph_map_size & 0x7fff;
3014 }
3015 }
3016 }
3017 else
3018 {
3019 GX_GLYPH* glyph;
3020 if (font->gx_font_format & GX_FONT_FORMAT_KERNING)
3021 {
3022 glyph = (GX_GLYPH *) &font->gx_font_glyphs.gx_font_kerning_glyphs[glyph_index];
3023 }
3024 else
3025 {
3026 glyph = (GX_GLYPH*) &(font->gx_font_glyphs.gx_font_normal_glyphs[glyph_index]);
3027 }
3028
3029 if (glyph->gx_glyph_map)
3030 {
3031 if (IsRotatedResourceSupported(m_project, m_display))
3032 {
3033 data_size = GetRowPitch(glyph->gx_glyph_height, GetFontBits(font->gx_font_format));
3034 data_size *= glyph->gx_glyph_width;
3035 }
3036 else
3037 {
3038 int pitch = GetRowPitch(glyph->gx_glyph_width, GetFontBits(font->gx_font_format));
3039 data_size = pitch * glyph->gx_glyph_height;
3040 }
3041 }
3042 }
3043
3044 if (data_size &&
3045 (project_lib_version() >= GX_VERSION_BINRES_FONT_ALIGNMENT_FIX) &&
3046 (written_size & 0x03))
3047 {
3048 data_size += (4 - (written_size & 0x03));
3049 }
3050 }
3051
3052 return data_size;
3053 }
3054
3055 ///////////////////////////////////////////////////////////////////////////////
GetStringDataSize()3056 ULONG binary_resource_gen::GetStringDataSize()
3057 {
3058 ULONG data_size = 0;
3059
3060 CCommandInfo *pCmd = GetCmdInfo();
3061 BOOL enabled;
3062
3063 data_size += GetStringHeaderSize();
3064 for (int language = 0; language < m_project->mHeader.num_languages; language++)
3065 {
3066 if (pCmd->IsNoGui())
3067 {
3068 enabled = pCmd->IsLanguageEnabled(m_project->mHeader.languages[language].name);
3069 }
3070 else
3071 {
3072 enabled = m_project->mDisplays[m_display].gen_string_table[language];
3073 }
3074
3075 if (enabled)
3076 {
3077 data_size += GetLanguageHeaderSize();
3078 data_size += GetStringDataSize(language);
3079 }
3080 }
3081
3082 return data_size;
3083 }
3084
3085 ///////////////////////////////////////////////////////////////////////////////
GetStringDataSize(USHORT language_id)3086 ULONG binary_resource_gen::GetStringDataSize(USHORT language_id)
3087 {
3088 ULONG string_data_size = 0;
3089
3090 string_table *pTable = m_project->mDisplays[m_display].stable;
3091 int num_strings = pTable->CountStrings();
3092 CString val;
3093 CString id_name;
3094 GX_STRING string;
3095 CArray<widget_info*>* info_list;
3096 widget_info* info;
3097 int reference_count;
3098
3099 // calcualte string data size
3100 for (int string_id = 1; string_id < num_strings; string_id++)
3101 {
3102 id_name = pTable->GetResourceIdName(string_id);
3103 val = pTable->GetString(id_name, language_id);
3104
3105 info_list = pTable->GetMLViewReferenceWidgetInfoList(id_name);
3106
3107 if (info_list)
3108 {
3109 reference_count = info_list->GetCount();
3110 }
3111 else
3112 {
3113 reference_count = 1;
3114 }
3115
3116 info = NULL;
3117
3118 for(int index = 0; index < reference_count; index++)
3119 {
3120 if (info_list)
3121 {
3122 info = info_list->GetAt(index);
3123 }
3124
3125 if (val.IsEmpty())
3126 {
3127 string.gx_string_ptr = GX_NULL;
3128 string.gx_string_length = 0;
3129 }
3130 else
3131 {
3132 MakeUtf8String(m_project, val, language_id, &string, m_display, TRUE, info);
3133 }
3134
3135 if (project_lib_version() >= GX_VERSION_STRING_LENGTH_FIX)
3136 {
3137 //two bytes for string length
3138 string_data_size += sizeof(USHORT);
3139 }
3140
3141 string_data_size += string.gx_string_length + 1;
3142 if (string.gx_string_ptr)
3143 {
3144 delete string.gx_string_ptr;
3145 }
3146 }
3147 }
3148
3149 return string_data_size;
3150 }
3151
3152 ////////////////////////////////////////////////////////////////////////////////////////////////
MakeFileDictionary(void)3153 void binary_resource_gen::MakeFileDictionary(void)
3154 {
3155 res_info* info;
3156 CCommandInfo* pCmdInfo = GetCmdInfo();
3157 BOOL enabled;
3158 CString output_file;
3159 file_info* finfo;
3160 ULONG blocksize;
3161
3162 finfo = new file_info();
3163 finfo->name = "";
3164 finfo->total_size = 0;
3165 finfo->write_res_index = 0;
3166 finfo->size_table.RemoveAll();
3167 m_file_dictionary.Add(finfo);
3168
3169 ULONG written_size = 0;
3170
3171 for (int theme = 0; theme < m_project->mDisplays[m_display].num_themes; theme++)
3172 {
3173 if (pCmdInfo->IsNoGui())
3174 {
3175 enabled = pCmdInfo->IsThemeEnabled(m_project->mDisplays[m_display].themes[theme].theme_name);
3176 }
3177 else
3178 {
3179 enabled = m_project->mDisplays[m_display].themes[theme].gen_pixelmap_table;
3180 }
3181
3182 if (!enabled) continue;
3183
3184 for (int font_id = 0; font_id < m_project->CountResources(m_display, RES_TYPE_FONT); font_id++)
3185 {
3186 res_info* info = m_project->FindResource(m_display, theme, RES_TYPE_FONT, font_id);
3187
3188 if (IsResEnabled(info))
3189 {
3190 if (info->output_file_enabled)
3191 {
3192 output_file = RemoveFileExtension(info->output_file);
3193 output_file.MakeUpper();
3194 finfo = FindFileInfo(&m_file_dictionary, output_file);
3195
3196 if (!finfo)
3197 {
3198 finfo = new file_info;
3199 finfo->name = output_file;
3200 finfo->total_size = 0;
3201 finfo->write_res_index = 0;
3202 finfo->size_table.RemoveAll();
3203 m_file_dictionary.Add(finfo);
3204 }
3205 }
3206 else
3207 {
3208 finfo = m_file_dictionary.GetAt(0);
3209 }
3210
3211 written_size = finfo->total_size;
3212 written_size += GetFontHeaderSize();
3213 blocksize = GetFontDataSize(written_size, info, theme, font_id);
3214 written_size += blocksize;
3215 blocksize += GetFontHeaderSize();
3216
3217 finfo->size_table.Add(blocksize);
3218 finfo->total_size = written_size;
3219 }
3220 }
3221
3222 GX_PIXELMAP *map;
3223 USHORT outmap_id = 1;
3224
3225 for (int id = 1; id < m_pixelmap_dictionary.GetCount(); id++)
3226 {
3227 info = m_project->FindResource(m_display, theme, RES_TYPE_PIXELMAP, m_pixelmap_dictionary.GetAt(id));
3228
3229 if (IsResEnabled(info) && info->GetPixelmapFrameCount())
3230 {
3231 for (int frame_id = 0; frame_id < info->GetPixelmapFrameCount(); frame_id++)
3232 {
3233 map = info->GetPixelmap(frame_id);
3234
3235 if (!map)
3236 {
3237 continue;
3238 }
3239
3240 if (info->output_file_enabled)
3241 {
3242 output_file = RemoveFileExtension(info->output_file);
3243 output_file.MakeUpper();
3244
3245 finfo = FindFileInfo(&m_file_dictionary, output_file);
3246
3247 if (!finfo)
3248 {
3249
3250 finfo = new file_info;
3251 finfo->name = output_file;
3252 finfo->total_size = 0;
3253 finfo->write_res_index = 0;
3254 finfo->size_table.RemoveAll();
3255 m_file_dictionary.Add(finfo);
3256 }
3257 }
3258 else
3259 {
3260 finfo = m_file_dictionary.GetAt(0);
3261 }
3262
3263 written_size = finfo->total_size;
3264 written_size += GetPixelmapHeaderSize();
3265 blocksize = GetOnePixelmapDataSize(written_size, info, theme, frame_id, outmap_id);
3266 written_size += blocksize;
3267 blocksize += GetPixelmapHeaderSize();
3268
3269 finfo->size_table.Add(blocksize);
3270 finfo->total_size = written_size;
3271
3272 outmap_id++;
3273 }
3274 }
3275 }
3276 }
3277 }
3278
3279 ////////////////////////////////////////////////////////////////////////////////////////////////
DestroyFileDictionay()3280 void binary_resource_gen::DestroyFileDictionay()
3281 {
3282 file_info* info;
3283 for (int index = 0; index < m_file_dictionary.GetCount(); index++)
3284 {
3285 info = m_file_dictionary.GetAt(index);
3286 delete info;
3287 }
3288
3289 m_file_dictionary.RemoveAll();
3290 }
3291
3292
3293 ///////////////////////////////////////////////////////////////////////////////
FindFileInfo(CArray<file_info * > * file_dict,CString name)3294 file_info *binary_resource_gen::FindFileInfo(CArray<file_info*>* file_dict, CString name)
3295 {
3296 file_info* find;
3297 int index;
3298
3299 for (index = 1; index < file_dict->GetCount(); index++)
3300 {
3301 find = file_dict->GetAt(index);
3302
3303 if (find->name == name)
3304 {
3305 return find;
3306 }
3307 }
3308
3309 return GX_NULL;
3310 }
