1 // copyright (c) 2017-2021 hors<horsicq@gmail.com>
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9
10 // The above copyright notice and this permission notice shall be included in all
11 // copies or substantial portions of the Software.
12
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 // SOFTWARE.
20 //
21 #include "dexwidget.h"
22 #include "ui_dexwidget.h"
23
DEXWidget(QWidget * pParent)24 DEXWidget::DEXWidget(QWidget *pParent) :
25 FormatWidget(pParent),
26 ui(new Ui::DEXWidget)
27 {
28 ui->setupUi(this);
29
30 g_pFilterStrings=new QSortFilterProxyModel(this);
31 g_pFilterTypes=new QSortFilterProxyModel(this);
32
33 initHexViewWidget(ui->widgetHex);
34 // initSearchSignaturesWidget(ui->widgetSignatures);
35 initSearchStringsWidget(ui->widgetStrings);
36 initToolsWidget(ui->widgetHex_Header);
37 }
38
DEXWidget(QIODevice * pDevice,FW_DEF::OPTIONS options,QWidget * pParent)39 DEXWidget::DEXWidget(QIODevice *pDevice, FW_DEF::OPTIONS options, QWidget *pParent) :
40 DEXWidget(pParent)
41 {
42 DEXWidget::setData(pDevice,options,0,0,0);
43 DEXWidget::reload();
44 }
45
~DEXWidget()46 DEXWidget::~DEXWidget()
47 {
48 delete ui;
49 }
50
setShortcuts(XShortcuts * pShortcuts)51 void DEXWidget::setShortcuts(XShortcuts *pShortcuts)
52 {
53 ui->widgetHex->setShortcuts(pShortcuts);
54 // ui->widgetDisasm->setShortcuts(pShortcuts);
55 ui->widgetStrings->setShortcuts(pShortcuts);
56 ui->widgetEntropy->setShortcuts(pShortcuts);
57 ui->widgetHeuristicScan->setShortcuts(pShortcuts);
58 ui->widgetMemoryMap->setShortcuts(pShortcuts);
59 ui->widgetHex_Header->setShortcuts(pShortcuts);
60
61 FormatWidget::setShortcuts(pShortcuts);
62 }
63
clear()64 void DEXWidget::clear()
65 {
66 DEXWidget::reset();
67
68 memset(g_lineEdit_HEADER,0,sizeof g_lineEdit_HEADER);
69 memset(g_comboBox,0,sizeof g_comboBox);
70 memset(g_invWidget,0,sizeof g_invWidget);
71 memset(g_subDevice,0,sizeof g_subDevice);
72 memset(g_tvModel,0,sizeof g_tvModel);
73
74 ui->checkBoxReadonly->setChecked(true);
75
76 ui->treeWidgetNavi->clear();
77 }
78
cleanup()79 void DEXWidget::cleanup()
80 {
81
82 }
83
reload()84 void DEXWidget::reload()
85 {
86 DEXWidget::clear();
87
88 ui->checkBoxReadonly->setEnabled(!isReadonly());
89
90 XDEX dex(getDevice());
91
92 if(dex.isValid())
93 {
94 setFileType(dex.getFileType());
95
96 ui->treeWidgetNavi->addTopLevelItem(createNewItem(SDEX::TYPE_HEX,tr("Hex")));
97 ui->treeWidgetNavi->addTopLevelItem(createNewItem(SDEX::TYPE_HASH,tr("Hash")));
98 ui->treeWidgetNavi->addTopLevelItem(createNewItem(SDEX::TYPE_STRINGS,tr("Strings")));
99 ui->treeWidgetNavi->addTopLevelItem(createNewItem(SDEX::TYPE_MEMORYMAP,tr("Memory map")));
100 ui->treeWidgetNavi->addTopLevelItem(createNewItem(SDEX::TYPE_ENTROPY,tr("Entropy")));
101 ui->treeWidgetNavi->addTopLevelItem(createNewItem(SDEX::TYPE_HEURISTICSCAN,tr("Heuristic scan")));
102 ui->treeWidgetNavi->addTopLevelItem(createNewItem(SDEX::TYPE_HEADER,"Header"));
103
104 QList<XDEX_DEF::MAP_ITEM> listMapItems=dex.getMapItems();
105
106 if(listMapItems.count())
107 {
108 QTreeWidgetItem *pItemMapItems=createNewItem(SDEX::TYPE_MAPITEMS,"Map items");
109
110 ui->treeWidgetNavi->addTopLevelItem(pItemMapItems);
111
112 if(dex.isMapItemPresent(XDEX_DEF::TYPE_STRING_ID_ITEM,&listMapItems))
113 {
114 pItemMapItems->addChild(createNewItem(SDEX::TYPE_STRING_ID_ITEM,"STRING_ID_ITEM"));
115 }
116
117 if(dex.isMapItemPresent(XDEX_DEF::TYPE_TYPE_ID_ITEM,&listMapItems))
118 {
119 pItemMapItems->addChild(createNewItem(SDEX::TYPE_TYPE_ID_ITEM,"TYPE_ID_ITEM"));
120 }
121
122 if(dex.isMapItemPresent(XDEX_DEF::TYPE_PROTO_ID_ITEM,&listMapItems))
123 {
124 pItemMapItems->addChild(createNewItem(SDEX::TYPE_PROTO_ID_ITEM,"PROTO_ID_ITEM"));
125 }
126
127 if(dex.isMapItemPresent(XDEX_DEF::TYPE_FIELD_ID_ITEM,&listMapItems))
128 {
129 pItemMapItems->addChild(createNewItem(SDEX::TYPE_FIELD_ID_ITEM,"TYPE_FIELD_ID_ITEM"));
130 }
131
132 if(dex.isMapItemPresent(XDEX_DEF::TYPE_METHOD_ID_ITEM,&listMapItems))
133 {
134 pItemMapItems->addChild(createNewItem(SDEX::TYPE_METHOD_ID_ITEM,"TYPE_METHOD_ID_ITEM"));
135 }
136
137 if(dex.isMapItemPresent(XDEX_DEF::TYPE_CLASS_DEF_ITEM,&listMapItems))
138 {
139 pItemMapItems->addChild(createNewItem(SDEX::TYPE_CLASS_DEF_ITEM,"TYPE_CLASS_DEF_ITEM"));
140 }
141 }
142
143 ui->treeWidgetNavi->expandAll();
144
145 setTreeItem(ui->treeWidgetNavi,getOptions().nStartType);
146 }
147 }
148
_setValue(QVariant vValue,int nStype,int nNdata,int nVtype,int nPosition,qint64 nOffset)149 FormatWidget::SV DEXWidget::_setValue(QVariant vValue, int nStype, int nNdata, int nVtype, int nPosition, qint64 nOffset)
150 {
151 Q_UNUSED(nVtype)
152 Q_UNUSED(nPosition)
153 Q_UNUSED(nOffset)
154
155 SV result=SV_NONE;
156
157 blockSignals(true);
158
159 quint64 nValue=vValue.toULongLong();
160 QString sValue=vValue.toString();
161
162 if(getDevice()->isWritable())
163 {
164 XDEX dex(getDevice());
165
166 if(dex.isValid())
167 {
168 switch(nStype)
169 {
170 case SDEX::TYPE_HEADER:
171 switch(nNdata)
172 {
173 case N_DEX_HEADER::magic: g_comboBox[CB_Dex_Header_magic]->setValue(nValue); break;
174 case N_DEX_HEADER::version: g_comboBox[CB_Dex_Header_version]->setValue(nValue); break;
175 case N_DEX_HEADER::endian_tag: g_comboBox[CB_Dex_Header_endian_tag]->setValue(nValue); break;
176 case N_DEX_HEADER::link_size: g_invWidget[INV_link]->setOffsetAndSize(&dex,dex.getHeader_link_off(),(quint32)nValue); break;
177 case N_DEX_HEADER::link_off: g_invWidget[INV_link]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_link_size()); break;
178 case N_DEX_HEADER::map_off: g_invWidget[INV_map]->setOffsetAndSize(&dex,(quint32)nValue,0); break;
179 case N_DEX_HEADER::string_ids_size: g_invWidget[INV_string_ids]->setOffsetAndSize(&dex,dex.getHeader_string_ids_off(),(quint32)nValue*sizeof(XDEX_DEF::STRING_ITEM_ID)); break;
180 case N_DEX_HEADER::string_ids_off: g_invWidget[INV_string_ids]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_string_ids_size()*sizeof(XDEX_DEF::STRING_ITEM_ID)); break;
181 case N_DEX_HEADER::type_ids_size: g_invWidget[INV_type_ids]->setOffsetAndSize(&dex,dex.getHeader_type_ids_off(),(quint32)nValue*sizeof(XDEX_DEF::TYPE_ITEM_ID)); break;
182 case N_DEX_HEADER::type_ids_off: g_invWidget[INV_type_ids]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_type_ids_size()*sizeof(XDEX_DEF::TYPE_ITEM_ID)); break;
183 case N_DEX_HEADER::proto_ids_size: g_invWidget[INV_proto_ids]->setOffsetAndSize(&dex,dex.getHeader_proto_ids_off(),(quint32)nValue*sizeof(XDEX_DEF::PROTO_ITEM_ID)); break;
184 case N_DEX_HEADER::proto_ids_off: g_invWidget[INV_proto_ids]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_proto_ids_size()*sizeof(XDEX_DEF::PROTO_ITEM_ID)); break;
185 case N_DEX_HEADER::field_ids_size: g_invWidget[INV_field_ids]->setOffsetAndSize(&dex,dex.getHeader_field_ids_off(),(quint32)nValue*sizeof(XDEX_DEF::FIELD_ITEM_ID)); break;
186 case N_DEX_HEADER::field_ids_off: g_invWidget[INV_field_ids]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_field_ids_size()*sizeof(XDEX_DEF::FIELD_ITEM_ID)); break;
187 case N_DEX_HEADER::method_ids_size: g_invWidget[INV_method_ids]->setOffsetAndSize(&dex,dex.getHeader_method_ids_off(),(quint32)nValue*sizeof(XDEX_DEF::METHOD_ITEM_ID)); break;
188 case N_DEX_HEADER::method_ids_off: g_invWidget[INV_method_ids]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_method_ids_size()*sizeof(XDEX_DEF::METHOD_ITEM_ID)); break;
189 case N_DEX_HEADER::class_defs_size: g_invWidget[INV_class_defs]->setOffsetAndSize(&dex,dex.getHeader_class_defs_off(),(quint32)nValue*sizeof(XDEX_DEF::CLASS_ITEM_DEF)); break;
190 case N_DEX_HEADER::class_defs_off: g_invWidget[INV_class_defs]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_class_defs_size()*sizeof(XDEX_DEF::CLASS_ITEM_DEF)); break;
191 case N_DEX_HEADER::data_size: g_invWidget[INV_data]->setOffsetAndSize(&dex,dex.getHeader_data_off(),(quint32)nValue); break;
192 case N_DEX_HEADER::data_off: g_invWidget[INV_data]->setOffsetAndSize(&dex,(quint32)nValue,dex.getHeader_data_size()); break;
193 }
194
195 break;
196 }
197
198 switch(nStype)
199 {
200 case SDEX::TYPE_HEADER:
201 switch(nNdata)
202 {
203 case N_DEX_HEADER::magic: dex.setHeader_magic((quint32)nValue); break;
204 case N_DEX_HEADER::version: dex.setHeader_version((quint32)nValue); break;
205 case N_DEX_HEADER::checksum: dex.setHeader_checksum((quint32)nValue); break;
206 case N_DEX_HEADER::file_size: dex.setHeader_file_size((quint32)nValue); break;
207 case N_DEX_HEADER::header_size: dex.setHeader_header_size((quint32)nValue); break;
208 case N_DEX_HEADER::endian_tag: dex.setHeader_endian_tag((quint32)nValue); break;
209 case N_DEX_HEADER::link_size: dex.setHeader_link_size((quint32)nValue); break;
210 case N_DEX_HEADER::link_off: dex.setHeader_link_off((quint32)nValue); break;
211 case N_DEX_HEADER::map_off: dex.setHeader_map_off((quint32)nValue); break;
212 case N_DEX_HEADER::string_ids_size: dex.setHeader_string_ids_size((quint32)nValue); break;
213 case N_DEX_HEADER::string_ids_off: dex.setHeader_string_ids_off((quint32)nValue); break;
214 case N_DEX_HEADER::type_ids_size: dex.setHeader_type_ids_size((quint32)nValue); break;
215 case N_DEX_HEADER::type_ids_off: dex.setHeader_type_ids_off((quint32)nValue); break;
216 case N_DEX_HEADER::proto_ids_size: dex.setHeader_proto_ids_size((quint32)nValue); break;
217 case N_DEX_HEADER::proto_ids_off: dex.setHeader_proto_ids_off((quint32)nValue); break;
218 case N_DEX_HEADER::field_ids_size: dex.setHeader_field_ids_size((quint32)nValue); break;
219 case N_DEX_HEADER::field_ids_off: dex.setHeader_field_ids_off((quint32)nValue); break;
220 case N_DEX_HEADER::method_ids_size: dex.setHeader_method_ids_size((quint32)nValue); break;
221 case N_DEX_HEADER::method_ids_off: dex.setHeader_method_ids_off((quint32)nValue); break;
222 case N_DEX_HEADER::class_defs_size: dex.setHeader_class_defs_size((quint32)nValue); break;
223 case N_DEX_HEADER::class_defs_off: dex.setHeader_class_defs_off((quint32)nValue); break;
224 case N_DEX_HEADER::data_size: dex.setHeader_data_size((quint32)nValue); break;
225 case N_DEX_HEADER::data_off: dex.setHeader_data_off((quint32)nValue); break;
226 }
227
228 ui->widgetHex_Header->reload();
229
230 break;
231 }
232
233 result=SV_EDITED;
234 }
235 }
236
237 blockSignals(false);
238
239 return result;
240 }
241
setReadonly(bool bState)242 void DEXWidget::setReadonly(bool bState)
243 {
244 setLineEditsReadOnly(g_lineEdit_HEADER,N_DEX_HEADER::__data_size,bState);
245 setComboBoxesReadOnly(g_comboBox,__CB_size,bState);
246
247 ui->widgetHex->setReadonly(bState);
248 }
249
blockSignals(bool bState)250 void DEXWidget::blockSignals(bool bState)
251 {
252 _blockSignals((QObject **)g_lineEdit_HEADER,N_DEX_HEADER::__data_size,bState);
253 _blockSignals((QObject **)g_comboBox,__CB_size,bState);
254 }
255
adjustHeaderTable(int nType,QTableWidget * pTableWidget)256 void DEXWidget::adjustHeaderTable(int nType, QTableWidget *pTableWidget)
257 {
258 XBinary::MODE mode=XDEX::getMode(getDevice());
259
260 pTableWidget->setColumnWidth(HEADER_COLUMN_OFFSET,getColumnWidth(this,CW_UINT16,mode));
261 pTableWidget->setColumnWidth(HEADER_COLUMN_TYPE,getColumnWidth(this,CW_TYPE,mode));
262
263 switch(nType)
264 {
265 case SDEX::TYPE_HEADER:
266 pTableWidget->setColumnWidth(HEADER_COLUMN_NAME,getColumnWidth(this,CW_STRINGSHORT,mode));
267 pTableWidget->setColumnWidth(HEADER_COLUMN_VALUE,getColumnWidth(this,CW_UINT32,mode));
268 pTableWidget->setColumnWidth(HEADER_COLUMN_INFO,getColumnWidth(this,CW_STRINGSHORT2,mode));
269 break;
270 }
271 }
272
typeIdToString(int nType)273 QString DEXWidget::typeIdToString(int nType)
274 {
275 Q_UNUSED(nType)
276
277 return "";
278 }
279
reloadData()280 void DEXWidget::reloadData()
281 {
282 int nType=ui->treeWidgetNavi->currentItem()->data(0,Qt::UserRole+FW_DEF::SECTION_DATA_TYPE).toInt();
283 qint64 nDataOffset=ui->treeWidgetNavi->currentItem()->data(0,Qt::UserRole+FW_DEF::SECTION_DATA_OFFSET).toLongLong();
284 qint64 nDataSize=ui->treeWidgetNavi->currentItem()->data(0,Qt::UserRole+FW_DEF::SECTION_DATA_SIZE).toLongLong();
285 // qint64 nDataExtraOffset=ui->treeWidgetNavi->currentItem()->data(0,Qt::UserRole+FW_DEF::SECTION_DATA_EXTRAOFFSET).toLongLong();
286 // qint64 nDataExtraSize=ui->treeWidgetNavi->currentItem()->data(0,Qt::UserRole+FW_DEF::SECTION_DATA_EXTRASIZE).toLongLong();
287
288 QString sInit=getInitString(ui->treeWidgetNavi->currentItem());
289
290 ui->stackedWidgetInfo->setCurrentIndex(nType);
291
292 XDEX dex(getDevice());
293
294 if(dex.isValid())
295 {
296 if(nType==SDEX::TYPE_HEX)
297 {
298 if(!isInitPresent(sInit))
299 {
300 XHexView::OPTIONS options={};
301 options.bMenu_Disasm=true;
302 options.bMenu_MemoryMap=true;
303 options.sSignaturesPath=getOptions().sSearchSignaturesPath;
304 ui->widgetHex->setData(getDevice(),options);
305 // ui->widgetHex->setBackupFileName(getOptions().sBackupFileName);
306 ui->widgetHex->enableReadOnly(false);
307
308 ui->widgetHex->reload();
309 }
310 }
311 else if(nType==SDEX::TYPE_HASH)
312 {
313 if(!isInitPresent(sInit))
314 {
315 ui->widgetHash->setData(getDevice(),dex.getFileType(),0,-1,true);
316 }
317 }
318 else if(nType==SDEX::TYPE_STRINGS)
319 {
320 if(!isInitPresent(sInit))
321 {
322 SearchStringsWidget::OPTIONS stringsOptions={};
323 stringsOptions.bMenu_Hex=true;
324 stringsOptions.bMenu_Demangle=true;
325 stringsOptions.bAnsi=true;
326 stringsOptions.bUTF8=false;
327 stringsOptions.bUnicode=true;
328
329 ui->widgetStrings->setData(getDevice(),stringsOptions,true);
330 }
331 }
332 else if(nType==SDEX::TYPE_MEMORYMAP)
333 {
334 if(!isInitPresent(sInit))
335 {
336 ui->widgetMemoryMap->setData(getDevice(),dex.getFileType(),getOptions().sSearchSignaturesPath);
337 }
338 }
339 else if(nType==SDEX::TYPE_ENTROPY)
340 {
341 if(!isInitPresent(sInit))
342 {
343 ui->widgetEntropy->setData(getDevice(),0,getDevice()->size(),dex.getFileType(),true);
344 }
345 }
346 else if(nType==SDEX::TYPE_HEURISTICSCAN)
347 {
348 if(!isInitPresent(sInit))
349 {
350 ui->widgetHeuristicScan->setData(getDevice(),true,XBinary::FT_DEX);
351 }
352 }
353 else if(nType==SDEX::TYPE_HEADER)
354 {
355 if(!isInitPresent(sInit))
356 {
357 createHeaderTable(SDEX::TYPE_HEADER,ui->tableWidget_Header,N_DEX_HEADER::records,g_lineEdit_HEADER,N_DEX_HEADER::__data_size,0);
358
359 g_comboBox[CB_Dex_Header_magic]=createComboBox(ui->tableWidget_Header,XDEX::getHeaderMagics(),SDEX::TYPE_HEADER,N_DEX_HEADER::magic,XComboBoxEx::CBTYPE_LIST);
360 g_comboBox[CB_Dex_Header_version]=createComboBox(ui->tableWidget_Header,XDEX::getHeaderVersions(),SDEX::TYPE_HEADER,N_DEX_HEADER::version,XComboBoxEx::CBTYPE_LIST);
361 g_comboBox[CB_Dex_Header_endian_tag]=createComboBox(ui->tableWidget_Header,XDEX::getHeaderEndianTags(),SDEX::TYPE_HEADER,N_DEX_HEADER::endian_tag,XComboBoxEx::CBTYPE_LIST);
362
363 g_invWidget[INV_link]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::link_off,InvWidget::TYPE_HEX);
364 g_invWidget[INV_map]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::map_off,InvWidget::TYPE_HEX);
365 g_invWidget[INV_string_ids]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::string_ids_off,InvWidget::TYPE_HEX);
366 g_invWidget[INV_type_ids]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::type_ids_off,InvWidget::TYPE_HEX);
367 g_invWidget[INV_proto_ids]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::proto_ids_off,InvWidget::TYPE_HEX);
368 g_invWidget[INV_field_ids]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::field_ids_off,InvWidget::TYPE_HEX);
369 g_invWidget[INV_method_ids]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::method_ids_off,InvWidget::TYPE_HEX);
370 g_invWidget[INV_class_defs]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::class_defs_off,InvWidget::TYPE_HEX);
371 g_invWidget[INV_data]=createInvWidget(ui->tableWidget_Header,SDEX::TYPE_HEADER,N_DEX_HEADER::data_off,InvWidget::TYPE_HEX);
372
373 blockSignals(true);
374
375 XDEX_DEF::HEADER header=dex.getHeader();
376
377 g_lineEdit_HEADER[N_DEX_HEADER::magic]->setValue(header.magic);
378 g_lineEdit_HEADER[N_DEX_HEADER::version]->setValue(header.version);
379 g_lineEdit_HEADER[N_DEX_HEADER::checksum]->setValue(header.checksum);
380
381 g_lineEdit_HEADER[N_DEX_HEADER::file_size]->setValue(header.file_size);
382 g_lineEdit_HEADER[N_DEX_HEADER::header_size]->setValue(header.header_size);
383 g_lineEdit_HEADER[N_DEX_HEADER::endian_tag]->setValue(header.endian_tag);
384 g_lineEdit_HEADER[N_DEX_HEADER::link_size]->setValue(header.link_size);
385 g_lineEdit_HEADER[N_DEX_HEADER::link_off]->setValue(header.link_off);
386 g_lineEdit_HEADER[N_DEX_HEADER::map_off]->setValue(header.map_off);
387 g_lineEdit_HEADER[N_DEX_HEADER::string_ids_size]->setValue(header.string_ids_size);
388 g_lineEdit_HEADER[N_DEX_HEADER::string_ids_off]->setValue(header.string_ids_off);
389 g_lineEdit_HEADER[N_DEX_HEADER::type_ids_size]->setValue(header.type_ids_size);
390 g_lineEdit_HEADER[N_DEX_HEADER::type_ids_off]->setValue(header.type_ids_off);
391 g_lineEdit_HEADER[N_DEX_HEADER::proto_ids_size]->setValue(header.proto_ids_size);
392 g_lineEdit_HEADER[N_DEX_HEADER::proto_ids_off]->setValue(header.proto_ids_off);
393 g_lineEdit_HEADER[N_DEX_HEADER::field_ids_size]->setValue(header.field_ids_size);
394 g_lineEdit_HEADER[N_DEX_HEADER::field_ids_off]->setValue(header.field_ids_off);
395 g_lineEdit_HEADER[N_DEX_HEADER::method_ids_size]->setValue(header.method_ids_size);
396 g_lineEdit_HEADER[N_DEX_HEADER::method_ids_off]->setValue(header.method_ids_off);
397 g_lineEdit_HEADER[N_DEX_HEADER::class_defs_size]->setValue(header.class_defs_size);
398 g_lineEdit_HEADER[N_DEX_HEADER::class_defs_off]->setValue(header.class_defs_off);
399 g_lineEdit_HEADER[N_DEX_HEADER::data_size]->setValue(header.data_size);
400 g_lineEdit_HEADER[N_DEX_HEADER::data_off]->setValue(header.data_off);
401
402 g_comboBox[CB_Dex_Header_magic]->setValue(header.magic);
403 g_comboBox[CB_Dex_Header_version]->setValue(header.version);
404 g_comboBox[CB_Dex_Header_endian_tag]->setValue(header.endian_tag);
405
406 g_invWidget[INV_link]->setOffsetAndSize(&dex,header.link_off,header.link_size);
407 g_invWidget[INV_map]->setOffsetAndSize(&dex,header.map_off,0);
408 g_invWidget[INV_string_ids]->setOffsetAndSize(&dex,header.string_ids_off,header.string_ids_size*sizeof(XDEX_DEF::STRING_ITEM_ID));
409 g_invWidget[INV_type_ids]->setOffsetAndSize(&dex,header.type_ids_off,header.type_ids_size*sizeof(XDEX_DEF::TYPE_ITEM_ID));
410 g_invWidget[INV_proto_ids]->setOffsetAndSize(&dex,header.proto_ids_off,header.proto_ids_size*sizeof(XDEX_DEF::PROTO_ITEM_ID));
411 g_invWidget[INV_field_ids]->setOffsetAndSize(&dex,header.field_ids_off,header.field_ids_size*sizeof(XDEX_DEF::FIELD_ITEM_ID));
412 g_invWidget[INV_method_ids]->setOffsetAndSize(&dex,header.method_ids_off,header.method_ids_size*sizeof(XDEX_DEF::METHOD_ITEM_ID));
413 g_invWidget[INV_class_defs]->setOffsetAndSize(&dex,header.class_defs_off,header.class_defs_size*sizeof(XDEX_DEF::CLASS_ITEM_DEF));
414 g_invWidget[INV_data]->setOffsetAndSize(&dex,header.data_off,header.data_size);
415
416 quint32 nHeaderSize=dex.getHeaderSize();
417
418 loadHexSubdevice(0,nHeaderSize,0,&g_subDevice[SDEX::TYPE_HEADER],ui->widgetHex_Header);
419
420 blockSignals(false);
421 }
422 }
423 else if(nType==SDEX::TYPE_MAPITEMS)
424 {
425 if(!isInitPresent(sInit))
426 {
427 DEXProcessData dexProcessData(SDEX::TYPE_MAPITEMS,&g_tvModel[SDEX::TYPE_MAPITEMS],&dex,nDataOffset,nDataSize);
428
429 ajustTableView(&dexProcessData,&g_tvModel[SDEX::TYPE_MAPITEMS],ui->tableView_MapItems);
430
431 if(g_tvModel[SDEX::TYPE_MAPITEMS]->rowCount())
432 {
433 ui->tableView_MapItems->setCurrentIndex(ui->tableView_MapItems->model()->index(0,0));
434 }
435 }
436 }
437 else if(nType==SDEX::TYPE_STRING_ID_ITEM)
438 {
439 if(!isInitPresent(sInit))
440 {
441 DEXProcessData dexProcessData(SDEX::TYPE_STRING_ID_ITEM,&g_tvModel[SDEX::TYPE_STRING_ID_ITEM],&dex,nDataOffset,nDataSize);
442
443 ajustTableView(&dexProcessData,&g_tvModel[SDEX::TYPE_STRING_ID_ITEM],ui->tableView_STRING_ID_ITEM,g_pFilterStrings);
444
445 if(g_tvModel[SDEX::TYPE_STRING_ID_ITEM]->rowCount())
446 {
447 ui->tableView_STRING_ID_ITEM->setCurrentIndex(ui->tableView_STRING_ID_ITEM->model()->index(0,0));
448 }
449 }
450 }
451 else if(nType==SDEX::TYPE_TYPE_ID_ITEM)
452 {
453 if(!isInitPresent(sInit))
454 {
455 DEXProcessData dexProcessData(SDEX::TYPE_TYPE_ID_ITEM,&g_tvModel[SDEX::TYPE_TYPE_ID_ITEM],&dex,nDataOffset,nDataSize);
456
457 ajustTableView(&dexProcessData,&g_tvModel[SDEX::TYPE_TYPE_ID_ITEM],ui->tableView_TYPE_ID_ITEM,g_pFilterTypes);
458
459 if(g_tvModel[SDEX::TYPE_TYPE_ID_ITEM]->rowCount())
460 {
461 ui->tableView_TYPE_ID_ITEM->setCurrentIndex(ui->tableView_TYPE_ID_ITEM->model()->index(0,0));
462 }
463 }
464 }
465 else if(nType==SDEX::TYPE_PROTO_ID_ITEM)
466 {
467 if(!isInitPresent(sInit))
468 {
469 DEXProcessData dexProcessData(SDEX::TYPE_PROTO_ID_ITEM,&g_tvModel[SDEX::TYPE_PROTO_ID_ITEM],&dex,nDataOffset,nDataSize);
470
471 ajustTableView(&dexProcessData,&g_tvModel[SDEX::TYPE_PROTO_ID_ITEM],ui->tableView_PROTO_ID_ITEM);
472
473 if(g_tvModel[SDEX::TYPE_PROTO_ID_ITEM]->rowCount())
474 {
475 ui->tableView_PROTO_ID_ITEM->setCurrentIndex(ui->tableView_PROTO_ID_ITEM->model()->index(0,0));
476 }
477 }
478 }
479 else if(nType==SDEX::TYPE_FIELD_ID_ITEM)
480 {
481 if(!isInitPresent(sInit))
482 {
483 DEXProcessData dexProcessData(SDEX::TYPE_FIELD_ID_ITEM,&g_tvModel[SDEX::TYPE_FIELD_ID_ITEM],&dex,nDataOffset,nDataSize);
484
485 ajustTableView(&dexProcessData,&g_tvModel[SDEX::TYPE_FIELD_ID_ITEM],ui->tableView_FIELD_ID_ITEM);
486
487 if(g_tvModel[SDEX::TYPE_FIELD_ID_ITEM]->rowCount())
488 {
489 ui->tableView_FIELD_ID_ITEM->setCurrentIndex(ui->tableView_FIELD_ID_ITEM->model()->index(0,0));
490 }
491 }
492 }
493 else if(nType==SDEX::TYPE_METHOD_ID_ITEM)
494 {
495 if(!isInitPresent(sInit))
496 {
497 DEXProcessData dexProcessData(SDEX::TYPE_METHOD_ID_ITEM,&g_tvModel[SDEX::TYPE_METHOD_ID_ITEM],&dex,nDataOffset,nDataSize);
498
499 ajustTableView(&dexProcessData,&g_tvModel[SDEX::TYPE_METHOD_ID_ITEM],ui->tableView_METHOD_ID_ITEM);
500
501 if(g_tvModel[SDEX::TYPE_METHOD_ID_ITEM]->rowCount())
502 {
503 ui->tableView_METHOD_ID_ITEM->setCurrentIndex(ui->tableView_METHOD_ID_ITEM->model()->index(0,0));
504 }
505 }
506 }
507 else if(nType==SDEX::TYPE_CLASS_DEF_ITEM)
508 {
509 if(!isInitPresent(sInit))
510 {
511 DEXProcessData dexProcessData(SDEX::TYPE_CLASS_DEF_ITEM,&g_tvModel[SDEX::TYPE_CLASS_DEF_ITEM],&dex,nDataOffset,nDataSize);
512
513 ajustTableView(&dexProcessData,&g_tvModel[SDEX::TYPE_CLASS_DEF_ITEM],ui->tableView_CLASS_DEF_ITEM);
514
515 if(g_tvModel[SDEX::TYPE_CLASS_DEF_ITEM]->rowCount())
516 {
517 ui->tableView_CLASS_DEF_ITEM->setCurrentIndex(ui->tableView_CLASS_DEF_ITEM->model()->index(0,0));
518 }
519 }
520 }
521
522 setReadonly(ui->checkBoxReadonly->isChecked());
523 }
524
525 addInit(sInit);
526 }
527
528
createSectionTable(int nType,QTableWidget * pTableWidget,const FW_DEF::HEADER_RECORD * pHeaderRecord,int nNumberOfRecords)529 bool DEXWidget::createSectionTable(int nType, QTableWidget *pTableWidget, const FW_DEF::HEADER_RECORD *pHeaderRecord, int nNumberOfRecords)
530 {
531 Q_UNUSED(nType)
532
533 QStringList slHeader;
534
535 pTableWidget->setRowCount(0);
536
537 for(int i=0; i<nNumberOfRecords; i++)
538 {
539 slHeader.append(pHeaderRecord[i].sName);
540 }
541
542 pTableWidget->setHorizontalHeaderLabels(slHeader);
543 pTableWidget->horizontalHeader()->setVisible(true);
544
545 return true;
546 }
547
widgetValueChanged(quint64 nValue)548 void DEXWidget::widgetValueChanged(quint64 nValue)
549 {
550 QWidget *pWidget=qobject_cast<QWidget *>(sender());
551 int nStype=pWidget->property("STYPE").toInt();
552 int nNdata=pWidget->property("NDATA").toInt();
553
554 switch(nStype)
555 {
556 case SDEX::TYPE_HEADER:
557 switch(nNdata)
558 {
559 case N_DEX_HEADER::magic: g_lineEdit_HEADER[N_DEX_HEADER::magic]->setValue((quint32)nValue); break;
560 }
561
562 break;
563 }
564 }
565
on_treeWidgetNavi_currentItemChanged(QTreeWidgetItem * pCurrent,QTreeWidgetItem * pPrevious)566 void DEXWidget::on_treeWidgetNavi_currentItemChanged(QTreeWidgetItem *pCurrent, QTreeWidgetItem *pPrevious)
567 {
568 Q_UNUSED(pPrevious)
569
570 if(pCurrent)
571 {
572 reloadData();
573 addPage(pCurrent);
574 ui->toolButtonPrev->setEnabled(isPrevPageAvailable());
575 ui->toolButtonNext->setEnabled(isNextPageAvailable());
576 }
577 }
578
on_checkBoxReadonly_toggled(bool bChecked)579 void DEXWidget::on_checkBoxReadonly_toggled(bool bChecked)
580 {
581 setReadonly(bChecked);
582 }
583
on_pushButtonReload_clicked()584 void DEXWidget::on_pushButtonReload_clicked()
585 {
586 ui->pushButtonReload->setEnabled(false);
587 reload();
588
589 QTimer::singleShot(1000,this,SLOT(enableButton()));
590 }
591
enableButton()592 void DEXWidget::enableButton()
593 {
594 ui->pushButtonReload->setEnabled(true);
595 }
596
on_tableWidget_Header_currentCellChanged(int nCurrentRow,int nCurrentColumn,int nPreviousRow,int nPreviousColumn)597 void DEXWidget::on_tableWidget_Header_currentCellChanged(int nCurrentRow, int nCurrentColumn, int nPreviousRow, int nPreviousColumn)
598 {
599 Q_UNUSED(nCurrentRow);
600 Q_UNUSED(nCurrentColumn);
601 Q_UNUSED(nPreviousRow);
602 Q_UNUSED(nPreviousColumn);
603
604 setHeaderTableSelection(ui->widgetHex_Header,ui->tableWidget_Header);
605 }
606
on_lineEditFilterStrings_textChanged(const QString & sString)607 void DEXWidget::on_lineEditFilterStrings_textChanged(const QString &sString)
608 {
609 g_pFilterStrings->setFilterRegExp(sString);
610 g_pFilterStrings->setFilterCaseSensitivity(Qt::CaseInsensitive);
611 g_pFilterStrings->setFilterKeyColumn(3);
612 }
613
on_lineEditFilterTypes_textChanged(const QString & sString)614 void DEXWidget::on_lineEditFilterTypes_textChanged(const QString &sString)
615 {
616 g_pFilterTypes->setFilterRegExp(sString);
617 g_pFilterTypes->setFilterCaseSensitivity(Qt::CaseInsensitive);
618 g_pFilterTypes->setFilterKeyColumn(3);
619 }
620
on_toolButtonPrev_clicked()621 void DEXWidget::on_toolButtonPrev_clicked()
622 {
623 setAddPageEnabled(false);
624 ui->treeWidgetNavi->setCurrentItem(getPrevPage());
625 setAddPageEnabled(true);
626 }
627
on_toolButtonNext_clicked()628 void DEXWidget::on_toolButtonNext_clicked()
629 {
630 setAddPageEnabled(false);
631 ui->treeWidgetNavi->setCurrentItem(getNextPage());
632 setAddPageEnabled(true);
633 }
634