PackageCanvas * PackageCanvas::read(char * & st, UmlCanvas * canvas, char * k) {
if (!strcmp(k, "packagecanvas_ref"))
return ((PackageCanvas *) dict_get(read_id(st), "packagecanvas", canvas));
else if (!strcmp(k, "packagecanvas")) {
int id = read_id(st);
BrowserNode * br = BrowserPackage::read_ref(st);
UmlColor color = UmlDefaultColor;
Uml3States in_tab = UmlDefaultState;
ShowContextMode context = DefaultShowContextMode;
Uml3States show_stereotype_properties = UmlDefaultState;;
k = read_keyword(st);
if (!strcmp(k, "name_in_tab")) {
in_tab = state(read_keyword(st));
k = read_keyword(st);
}
if (!strcmp(k, "show_context_mode")) {
context = context_mode(read_keyword(st));
k = read_keyword(st);
}
if (!strcmp(k, "show_stereotype_properties")) {
show_stereotype_properties = state(read_keyword(st));
k = read_keyword(st);
}
read_color(st, "color", color, k);
if (strcmp(k, "xyzwh"))
wrong_keyword(k, "xyzwh");
int x = (int) read_double(st);
PackageCanvas * result =
new PackageCanvas(br, canvas, x, (int) read_double(st), id);
read_zwh(st, result);
if (read_file_format() >= 58) {
k = read_keyword(st);
result->read_stereotype_property(st, k); // updates k
if (strcmp(k, "end"))
wrong_keyword(k, "end");
}
result->name_in_tab = in_tab;
result->show_context_mode = context;
result->show_stereotype_properties = show_stereotype_properties;
result->itscolor = color;
result->check_size();
result->set_center100();
result->show();
result->check_stereotypeproperties();
return result;
}
else
return 0;
}
AssocContainCanvas * AssocContainCanvas::read(char * & st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "containcanvas_ref"))
return ((AssocContainCanvas *) dict_get(read_id(st), "contain canvas", canvas));
else if (!strcmp(k, "containcanvas")) {
int id = read_id(st);
LineGeometry geo;
bool fixed;
k = read_keyword(st); // may read id
if (!strcmp(k, "geometry")) {
geo = line_geometry(read_keyword(st));
k = read_keyword(st);
if (! strcmp(k, "unfixed")) {
k = read_keyword(st);
fixed = FALSE;
}
else
fixed = TRUE;
}
else {
geo = NoGeometry;
fixed = FALSE;
}
float dbegin;
float dend;
if (! strcmp(k, "decenter_begin")) {
dbegin = read_double(st) / 1000;
k = read_keyword(st);
}
else
dbegin = -1;
if (! strcmp(k, "decenter_end")) {
dend = read_double(st) / 1000;
k = read_keyword(st);
}
else
dend = -1;
unread_keyword(k, st);
AssocContainCanvas * r = (AssocContainCanvas *)
read_list(st, canvas, UmlContain, geo, fixed, dbegin, dend, id, &make);
// remove association between components available in the
// 2.0 deployment diagrams
if (r->begin->type() == UmlComponent)
Undefined.append(r);
else if (read_file_format() == 30)
// to remove redondant transitions made by release 2.22
RelsToCheck.append(r);
return r;
}
else
return 0;
}
void BrowserNode::read(char * & st, char * & k, int id) {
if (in_lib_import()) {
original_id = id;
is_read_only = TRUE;
if (! strcmp(k, "oid")) {
// a sub lib is imported as a part of the imported lib
(void) read_id(st);
k = read_keyword(st);
}
}
else if (! strcmp(k, "oid")) {
original_id = read_id(st);
is_read_only = TRUE;
k = read_keyword(st);
}
HaveKeyValueData::read(st, k);
if (!strcmp(k, "comment")) {
comment = read_string(st);
k = read_keyword(st);
}
is_new = FALSE;
}
DeploymentNodeCanvas * DeploymentNodeCanvas::read(char * & st, UmlCanvas * canvas, char * k) {
if (!strcmp(k, "deploymentnodecanvas_ref"))
return ((DeploymentNodeCanvas *) dict_get(read_id(st), "deploymentnodecanvas", canvas));
else if (!strcmp(k, "deploymentnodecanvas")) {
int id = read_id(st);
BrowserNode * br = BrowserDeploymentNode::read_ref(st);
QString iname;
Uml3States write_horizontally = UmlDefaultState;
Uml3States show_stereotype_properties = UmlDefaultState;
k = read_keyword(st);
if (!strcmp(k, "name")) {
iname = read_string(st);
k = read_keyword(st);
}
if (!strcmp(k, "write_horizontally") ||
!strcmp(k, "write_horizontaly")) {
write_horizontally = state(read_keyword(st));
k = read_keyword(st);
}
if (!strcmp(k, "show_stereotype_properties")) {
show_stereotype_properties = state(read_keyword(st));
k = read_keyword(st);
}
UmlColor color = UmlDefaultColor;
read_color(st, "color", color, k);
if (strcmp(k, "xyzwh"))
wrong_keyword(k, "xyzwh");
int x = (int) read_double(st);
DeploymentNodeCanvas * result =
new DeploymentNodeCanvas(br, canvas, x, (int) read_double(st), id);
read_zwh(st, result);
if (read_file_format() >= 58) {
k = read_keyword(st);
result->read_stereotype_property(st, k); // updates k
if (strcmp(k, "end"))
wrong_keyword(k, "end");
}
result->iname = iname;
result->write_horizontally = write_horizontally;
result->show_stereotype_properties = show_stereotype_properties;
result->itscolor = color;
result->check_size();
result->set_center100();
result->show();
result->check_stereotypeproperties();
return result;
}
else
return 0;
}
SubjectCanvas * SubjectCanvas::read(char * & st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "subject_ref"))
return (SubjectCanvas *) dict_get(read_id(st), "subject", canvas);
else if (!strcmp(k, "subject")) {
int id = read_id(st);
SubjectCanvas * result = new SubjectCanvas(canvas, 0, 0, id);
result->name = toUnicode(read_string(st));
k = read_keyword(st);
read_color(st, "color", result->itscolor, k);
if (strcmp(k, "xyzwh"))
wrong_keyword(k, "xyzwh");
read_xyzwh(st, result);
result->check_size();
result->width_scale100 = result->width();
result->height_scale100 = result->height();
result->set_center100();
result->show();
return result;
}
else
return 0;
}
UcUseCaseCanvas * UcUseCaseCanvas::read(char * & st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "usecasecanvas_ref"))
return ((UcUseCaseCanvas *) dict_get(read_id(st), "usecasecanvas", canvas));
else if (!strcmp(k, "usecasecanvas")) {
int id = read_id(st);
BrowserNode * br = BrowserUseCase::read_ref(st);
UmlColor color = UmlDefaultColor;
k = read_keyword(st);
read_color(st, "color", color, k);
if (strcmp(k, "xyzwh"))
wrong_keyword(k, "xyzwh");
int x = (int) read_double(st);
UcUseCaseCanvas * result =
new UcUseCaseCanvas(br, canvas, x, (int) read_double(st), id);
result->itscolor = color;
read_zwh(st, result);
result->width_scale100 = result->width();
result->height_scale100 = result->height();
result->set_center100();
k = read_keyword(st);
result->update_name();
read_xy(st, result->label);
result->label->setZ(result->z() + 0.5);
result->label->set_center100();
if (!strcmp(k, "label_xyz"))
// old version
read_double(st);
else if (strcmp(k, "label_xy"))
wrong_keyword(k, "label_xy/label_xyz");
if (read_file_format() >= 58) {
k = read_keyword(st);
result->read_stereotype_property(st, k); // updates k
if (strcmp(k, "end"))
wrong_keyword(k, "end");
}
result->show();
result->check_stereotypeproperties();
return result;
}
else
return 0;
}
NoteCanvas * NoteCanvas::read(char *& st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "note_ref"))
return (NoteCanvas *) dict_get(read_id(st), "note", canvas);
else if (!strcmp(k, "note")) {
int id = read_id(st);
NoteCanvas * result = new NoteCanvas(canvas, 0, 0, id);
result->read_internal(st);
return result;
}
else
return 0;
}
ActivityPartitionCanvas *
ActivityPartitionCanvas::read(char * & st, UmlCanvas * canvas,
char * k)
{
if (!strcmp(k, "activitypartitioncanvas_ref"))
return ((ActivityPartitionCanvas *) dict_get(read_id(st), "activitypartitioncanvas", canvas));
else if (!strcmp(k, "activitypartitioncanvas")) {
int id = read_id(st);
BrowserActivityPartition * br =
BrowserActivityPartition::read_ref(st);
ActivityPartitionCanvas * result =
new ActivityPartitionCanvas(canvas, id);
result->browser_node = br;
connect(br->get_data(), SIGNAL(changed()), result, SLOT(modified()));
connect(br->get_data(), SIGNAL(deleted()), result, SLOT(deleted()));
k = read_keyword(st);
read_color(st, "color", result->itscolor, k); // updates k
if (! strcmp(k, "horiz")) {
result->horiz = TRUE;
k = read_keyword(st);
}
result->read_stereotype_property(st, k); // updates k
if (!strcmp(k, "xyzwh"))
read_xyzwh(st, result);
else
wrong_keyword(k, "xyzwh");
result->check_size();
result->width_scale100 = result->width();
result->height_scale100 = result->height();
result->set_center100();
result->show();
result->check_stereotypeproperties();
read_keyword(st, "end");
// result->force_sub_inside() useless
if (canvas->paste())
result->remove_if_already_present();
return result;
}
else
return 0;
}
InfoCanvas * InfoCanvas::read(char * & st, UmlCanvas * canvas,
char * k, DiagramItem * who)
{
if (!strcmp(k, "information_ref"))
return (InfoCanvas *) dict_get(read_id(st), "information", canvas);
else if (!strcmp(k, "information")) {
int id = read_id(st);
InfoCanvas * result = new InfoCanvas(canvas, who, 0, 0, id);
result->read_internal(st);
return result;
}
else
return 0;
}
StateActionCanvas * StateActionCanvas::read(char * & st, UmlCanvas * canvas,
char * k)
{
if (!strcmp(k, "stateactioncanvas_ref"))
return ((StateActionCanvas *) dict_get(read_id(st), "stateactioncanvas", canvas));
else if (!strcmp(k, "stateactioncanvas")) {
int id = read_id(st);
BrowserStateAction * br = BrowserStateAction::read_ref(st);
StateActionCanvas * result = new StateActionCanvas(canvas, id);
result->browser_node = br;
connect(br->get_data(), SIGNAL(changed()), result, SLOT(modified()));
connect(br->get_data(), SIGNAL(deleted()), result, SLOT(deleted()));
k = read_keyword(st);
if (!strcmp(k, "language")) {
result->language = drawing_language(read_keyword(st));
k = read_keyword(st);
}
if (!strcmp(k, "show_stereotype_properties")) {
result->show_stereotype_properties = state(read_keyword(st));
k = read_keyword(st);
}
read_color(st, "color", result->itscolor, k); // updates k
if (!strcmp(k, "xyzwh"))
read_xyzwh(st, result);
else
wrong_keyword(k, "xyzwh");
if (read_file_format() >= 58) {
k = read_keyword(st);
result->read_stereotype_property(st, k); // updates k
if (strcmp(k, "end"))
wrong_keyword(k, "end");
}
result->compute_size();
result->set_center100();
result->show();
result->check_stereotypeproperties();
return result;
}
else
return 0;
}
static void
wd_fdc_seek_verify_read_id( wd_fdc *f )
{
fdd_t *d = f->current_drive;
int i;
f->read_id = 1;
event_remove_type( fdc_event );
if( f->id_mark == WD_FDC_AM_NONE ) {
while( f->rev ) {
i = d->disk.i >= d->disk.bpt ? 0 : d->disk.i; /* start position */
if( !read_id( f ) ) {
if( f->id_track != f->track_register ) {
f->status_register |= WD_FDC_SR_RNF;
}
} else
f->id_mark = WD_FDC_AM_NONE;
i = d->disk.bpt ? ( d->disk.i - i ) * 200 / d->disk.bpt : 200;
if( i > 0 ) {
event_add_with_data( tstates + i * /* i * 1/20 revolution */
machine_current->timings.processor_speed / 1000,
fdc_event, f );
return;
} else if( f->id_mark != WD_FDC_AM_NONE )
break;
}
if( f->id_mark == WD_FDC_AM_NONE )
f->status_register |= WD_FDC_SR_RNF;
}
f->state = WD_FDC_STATE_NONE;
f->status_register &= ~WD_FDC_SR_BUSY;
wd_fdc_set_intrq( f );
f->read_id = 0;
}
static void
start_read_diag( upd_fdc *f )
{
int i;
if( !f->read_id ) {
f->rev = 2;
f->read_id = 1;
}
if( f->rev ) {
i = f->current_drive->disk.i >= f->current_drive->disk.bpt ?
0 : f->current_drive->disk.i; /* start position */
if( read_id( f ) != 2 )
f->rev = 0;
i = f->current_drive->disk.bpt ?
( f->current_drive->disk.i - i ) * 200 / f->current_drive->disk.bpt : 200;
if( i > 0 ) {
event_add_with_data( tstates + i * /* i * 1/20 revolution */
machine_current->timings.processor_speed / 1000,
fdc_event, f );
return;
}
}
f->read_id = 0;
if( f->id_mark == UPD_FDC_AM_NONE ) {
f->status_register[0] |= UPD_FDC_ST0_INT_ABNORM;
f->status_register[1] |= UPD_FDC_ST1_EOF_CYLINDER;
goto abort_read_diag;
}
if( f->id_track != f->data_register[1] || f->id_sector != f->data_register[3] ||
f->data_register[2] != f->id_head ) {
f->status_register[1] |= UPD_FDC_ST1_NO_DATA;
}
if( f->id_track != f->data_register[1] ) { /*FIXME UPD765 set it always? */
f->status_register[2] |= UPD_FDC_ST2_WRONG_CYLINDER;
if( f->id_track == 0xff )
f->status_register[2] |= UPD_FDC_ST2_BAD_CYLINDER;
}
if( read_datamark( f ) > 0 ) { /* not found */
f->status_register[0] |= UPD_FDC_ST0_INT_ABNORM;
goto abort_read_diag;
}
f->main_status |= UPD_FDC_MAIN_DATAREQ | UPD_FDC_MAIN_DATA_READ;
f->data_offset = 0;
event_remove_type( timeout_event );
event_add_with_data( tstates + 4 * /* 2 revolution: 2 * 200 / 1000 */
machine_current->timings.processor_speed / 10,
timeout_event, f );
return;
abort_read_diag:
f->state = UPD_FDC_STATE_RES; /* end of execution phase */
f->cycle = f->cmd->res_length;
f->main_status &= ~UPD_FDC_MAIN_EXECUTION;
f->intrq = UPD_INTRQ_RESULT;
cmd_result( f );
}
/* Read out a given typed element */
static jvalue
read_val(unsigned char **pp, HprofType ty)
{
jvalue val;
static jvalue empty_val;
val = empty_val;
switch ( ty ) {
case 0:
case HPROF_ARRAY_OBJECT:
case HPROF_NORMAL_OBJECT:
val.i = read_id(pp);
break;
case HPROF_BYTE:
case HPROF_BOOLEAN:
val.b = read_u1(pp);
break;
case HPROF_CHAR:
case HPROF_SHORT:
val.s = read_u2(pp);
break;
case HPROF_FLOAT:
case HPROF_INT:
val.i = read_u4(pp);
break;
case HPROF_DOUBLE:
case HPROF_LONG:
val.j = read_u8(pp);
break;
default:
HPROF_ERROR(JNI_TRUE, "bad type number");
break;
}
return val;
}
static int
seek_id( upd_fdc *f )
{
int r;
f->status_register[2] &= ~( UPD_FDC_ST2_WRONG_CYLINDER |
UPD_FDC_ST2_BAD_CYLINDER );
r = read_id( f );
if( r != 0 ) return r; /* not found any good id */
if( f->id_track != f->data_register[1] ) {
f->status_register[2] |= UPD_FDC_ST2_WRONG_CYLINDER;
if( f->id_track == 0xff )
f->status_register[2] |= UPD_FDC_ST2_BAD_CYLINDER;
return 3;
}
if( f->id_sector == f->data_register[3] &&
f->id_head == f->data_register[2] ) {
if( f->id_length != f->data_register[4] ) {
f->status_register[1] |= UPD_FDC_ST1_NO_DATA;
return 3;
}
return 0;
}
f->status_register[1] |= UPD_FDC_ST1_NO_DATA;
return 3;
}
static size_t ack_skip(Buffer& buf)
{
const size_t len = buf.pop_front();
for (size_t i = 0; i < len; ++i)
read_id(buf);
return len;
}
SdSelfMsgCanvas * SdSelfMsgCanvas::read(char * & st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "reflexivemsg_ref"))
return ((SdSelfMsgCanvas *) dict_get(read_id(st), "reflexivemsg", canvas));
if (!strcmp(k, "selfreflexivemsg_ref"))
return ((SdSelfMsgCanvas *) dict_get(read_id(st), "selfreflexivemsg", canvas));
else if (!strcmp(k, "reflexivemsg") || !strcmp(k, "selfreflexivemsg")) {
int id = read_id(st);
UmlCode c;
if (*k == 's')
c = UmlSelfReturnMsg;
else {
k = read_keyword(st);
if (!strcmp(k, "synchronous"))
c = UmlSyncSelfMsg;
else if (!strcmp(k, "asynchronous"))
c = UmlAsyncSelfMsg;
else {
wrong_keyword(k, "synchronous/asynchronous");
return 0; // to avoid warning
}
}
read_keyword(st, "to");
SdDurationCanvas * d = SdDurationCanvas::read(st, canvas, TRUE);
k = read_keyword(st);
SdSelfMsgCanvas * result =
new SdSelfMsgCanvas(canvas, d, c, (int) read_double(st) - 1, id);
if (!strcmp(k, "yz"))
// new version
result->setZ(read_double(st));
else if (strcmp(k, "y"))
wrong_keyword(k, "y/yz");
result->SdMsgBaseCanvas::read(st);
return result;
}
else
return 0;
}
StereotypePropertiesCanvas *
StereotypePropertiesCanvas::read(char *& st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "stereotypeproperties_ref"))
return (StereotypePropertiesCanvas *) dict_get(read_id(st), "stereotypeproperties", canvas);
else
return 0;
}
FragmentCanvas * FragmentCanvas::read(char * & st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "fragment_ref"))
return (FragmentCanvas *) dict_get(read_id(st), "fragment", canvas);
else if (!strcmp(k, "fragment")) {
int id = read_id(st);
FragmentCanvas * result = new FragmentCanvas(canvas, 0, 0, id);
result->name = read_string(st);
k = read_keyword(st);
read_color(st, "color", result->itscolor, k);
if (!strcmp(k, "refer")) {
result->refer = BrowserDiagram::read_diagram_ref(st);
connect(result->refer->get_data(), SIGNAL(changed()), result, SLOT(modified()));
connect(result->refer->get_data(), SIGNAL(deleted()), result, SLOT(modified()));
k = read_keyword(st);
}
if (! strcmp(k, "form")) {
result->form = read_string(st);
k = read_keyword(st);
}
if (strcmp(k, "xyzwh"))
wrong_keyword(k, "xyzwh");
read_xyzwh(st, result);
result->check_size();
result->width_scale100 = result->width();
result->height_scale100 = result->height();
result->set_center100();
result->show();
if (read_file_format() >= 28) {
while (strcmp(k = read_keyword(st), "end"))
result->separators.append(FragmentSeparatorCanvas::read(st, canvas, k, result));
}
return result;
}
else
return 0;
}
SdDurationCanvas * SdDurationCanvas::read(char * & st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "durationcanvas_ref"))
return ((SdDurationCanvas *) dict_get(read_id(st), "durationcanvas", canvas));
else if (!strcmp(k, "durationcanvas")) {
int id = read_id(st);
SdObjCanvas * o;
k = read_keyword(st);
if ((o = SdClassInstCanvas::read(st, canvas, k)) == 0)
wrong_keyword(st, k);
return read_internal(st, canvas, id, o->get_life_line());
}
else
return 0;
}
// copy ACKs from buffer to self
void read(Buffer& buf)
{
const size_t len = buf.pop_front();
for (size_t i = 0; i < len; ++i)
{
const id_t id = read_id(buf);
data.push_back(id);
}
}
static size_t ack(REL_SEND& rel_send, Buffer& buf, const bool live)
{
const size_t len = buf.pop_front();
for (size_t i = 0; i < len; ++i)
{
const id_t id = read_id(buf);
if (live)
rel_send.ack(id);
}
return len;
}
ArtifactCanvas * ArtifactCanvas::read(char * & st, UmlCanvas * canvas,
char * k)
{
if (!strcmp(k, "artifactcanvas_ref") ||
((read_file_format() < 20) && !strcmp(k, "componentcanvas_ref")))
return ((ArtifactCanvas *) dict_get(read_id(st), "artifactcanvas", canvas));
else if (!strcmp(k, "artifactcanvas") ||
((read_file_format() < 20) && !strcmp(k, "componentcanvas"))) {
int id = read_id(st);
BrowserArtifact * br = BrowserArtifact::read_ref(st, read_keyword(st));
ArtifactCanvas * result = new ArtifactCanvas(canvas, id);
result->browser_node = br;
connect(br->get_data(), SIGNAL(changed()), result, SLOT(modified()));
connect(br->get_data(), SIGNAL(deleted()), result, SLOT(deleted()));
k = read_keyword(st);
read_color(st, "color", result->itscolor, k); // updates k
if (strcmp(k, "xyz"))
wrong_keyword(k, "xyz");
read_xyz(st, result);
if (read_file_format() >= 58) {
k = read_keyword(st);
result->read_stereotype_property(st, k); // updates k
if (strcmp(k, "end"))
wrong_keyword(k, "end");
}
result->compute_size();
result->set_center100();
result->show();
result->check_stereotypeproperties();
return result;
}
else
return 0;
}
ImageCanvas * ImageCanvas::read(char * & st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "image_ref"))
return (ImageCanvas *) dict_get(read_id(st), "image", canvas);
else if (!strcmp(k, "image")) {
int id = read_id(st);
QString pa = toUnicode(read_string(st));
ImageCanvas * result = new ImageCanvas(canvas, 0, 0, pa, id);
read_keyword(st, "xyz");
read_xyz(st, result);
read_keyword(st, "end");
result->set_center100();
result->show();
return result;
}
else
return 0;
}
/***************************************************************************
Function: cgiMain
Description:
Input:
Output:
Return: 0 OK, other Error
Others: none
***************************************************************************/
int cgiMain()
{
char account[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1]; //16 + terminating null
char password[FEATURE_GDGL_PASSWD_MAX_LEN + 1]; //16 + terminating null
char gateway_id[FEATURE_GDGL_ID_LEN + 1]; //12 + terminating null
char gateway_alias[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1];
char gateway_passwd[FEATURE_GDGL_PASSWD_MAX_LEN + 1];
cgiFormResultType cgi_re;
int res;
cgiHeaderContentType("application/json"); //MIME
// Read ID
res = read_id(gateway_id);
if (res != 0) {
client_admin_response("noid", res, clientAdminResultStr[res]);
return res;
}
// Read alias
res = read_alias(gateway_alias);
if (res != 0) {
client_admin_response(gateway_id, res, clientAdminResultStr[res]);
return res;
}
// Read password
res = read_password(gateway_passwd);
if (res != 0) {
client_admin_response(gateway_id, res, clientAdminResultStr[res]);
return res;
}
// Check account
cgi_re = cgiFormString("account", account, FEATURE_GDGL_ACCOUNT_MAX_LEN + 1);
res = check_account(cgi_re, account, gateway_id, gateway_alias);
if (res != 0) {
client_admin_response(gateway_id, res, clientAdminResultStr[res]);
return res;
}
// Check password
cgi_re = cgiFormString("password", password, FEATURE_GDGL_PASSWD_MAX_LEN + 1);
res = check_password(cgi_re, password, gateway_passwd);
if (res != 0) {
client_admin_response(gateway_id, res, clientAdminResultStr[res]);
return res;
}
// account & password all right
client_admin_response(gateway_id, clientAdminSuccess, clientAdminResultStr[clientAdminSuccess]);
return 0;
}
TextCanvas * TextCanvas::read(char *& st, UmlCanvas * canvas, char * k)
{
if (!strcmp(k, "textcanvas_ref"))
return ((TextCanvas *) dict_get(read_id(st), "textcanvas", canvas));
else if (!strcmp(k, "textcanvas")) {
int id = read_id(st);
QString text = read_string(st);
UmlFont font;
UmlColor fg_c = UmlBlack;
UmlColor bg_c = UmlTransparent;
k = read_keyword(st);
read_font(st, "font", font, k);
read_color(st, "fg", fg_c, k);
read_color(st, "bg", bg_c, k);
if (strcmp(k, "xyzwh"))
wrong_keyword(k, "xyzwh");
int x = (int) read_double(st);
TextCanvas * result =
new TextCanvas(canvas, x, (int) read_double(st), id);
read_zwh(st, result);
result->width_scale100 = result->width();
result->height_scale100 = result->height();
result->set_center100();
result->text = text;
result->itsfont = font;
result->fg_c = fg_c;
result->bg_c = bg_c;
result->show();
return result;
}
else
return 0;
}
std::pair<ChunkId, std::string> Parser::read_chunk(std::istream &stream)
{
// LastPass blob chunk is made up of 4-byte ID, big endian 4-byte size and payload of that size
// Example:
// 0000: 'IDID'
// 0004: 4
// 0008: 0xDE 0xAD 0xBE 0xEF
// 000C: --- Next chunk ---
auto id = read_id(stream);
auto payload = read_payload(stream, read_size(stream));
return std::make_pair(id, payload);
}
void read_ids() {
FILE * fp;
fp = fopen("../ids_table.txt", "r");
if (fp == NULL)
exit(EXIT_FAILURE);
while (!feof(fp)) {
read_id(fp);
}
fclose(fp);
ids = inverse_node_s(ids, NULL);
}
HubCanvas * HubCanvas::read(char *& st, UmlCanvas * canvas,
char * k)
{
if (!strcmp(k, "hubcanvas_ref"))
return ((HubCanvas *) dict_get(read_id(st), "hubcanvas", canvas));
if (strcmp(k, "hubcanvas"))
return 0;
int id = read_id(st);
read_keyword(st, "xyz");
int x = (int) read_double(st);
HubCanvas * result =
new HubCanvas(canvas, x, (int) read_double(st), id);
result->setZ(read_double(st));
result->show();
return result;
}
SdLostFoundMsgSupportCanvas * SdLostFoundMsgSupportCanvas::read(char * & st,
UmlCanvas * canvas,
char * k)
{
if (!strcmp(k, "lostfoundmsgsupport_ref"))
return ((SdLostFoundMsgSupportCanvas *) dict_get(read_id(st), "lostfoundmsgsupport", canvas));
if (strcmp(k, "lostfoundmsgsupport"))
return 0;
int id = read_id(st);
read_keyword(st, "xyz");
int x = (int) read_double(st);
SdLostFoundMsgSupportCanvas * result =
new SdLostFoundMsgSupportCanvas(canvas, x, (int) read_double(st), id);
result->setZ(read_double(st));
result->show();
return result;
}
ParameterSetCanvas * ParameterSetCanvas::read(char * & st, UmlCanvas * canvas,
char * k, ActivityActionCanvas * a) {
if (!strcmp(k, "parametersetcanvas_ref"))
return ((ParameterSetCanvas *) dict_get(read_id(st), "parametersetcanvas", canvas));
else if (!strcmp(k, "parametersetcanvas")) {
int id = read_id(st);
BrowserParameterSet * br = BrowserParameterSet::read_ref(st);
ParameterSetCanvas * result = new ParameterSetCanvas(br, canvas, id, a);
k = read_keyword(st);
read_color(st, "color", result->itscolor, k); // updates k
if (!strcmp(k, "xyz"))
read_xyz(st, result);
else
wrong_keyword(k, "xyz");
// note : width_scale100 & height_scale100 useless, position depend on pins
result->update();
result->show();
k = read_keyword(st);
result->read_stereotype_property(st, k); // updates k
if (strcmp(k, "end"))
wrong_keyword(k, "end");
result->check_stereotypeproperties();
return result;
}
else
return 0;
}
