edit_sequential.c

Source code for an Numeric Cmputer

	}
    }

    LeftX = Ele1X;
    RightX = Ele1X;
    if (LeftX > Ele2X)
	LeftX = Ele2X;
    if (RightX < Ele2X)
	RightX = Ele2X;

    if (pOffsetTransiFound != NULL)
	*pOffsetTransiFound = OffsetTransiFound;
    if (pStepsBaseY != NULL)
	*pStepsBaseY = StepsBaseY;
    if (pTransitionsBaseY != NULL)
	*pTransitionsBaseY = TransitionsBaseY;
    *pLeftX = LeftX;
    *pRightX = RightX;
    printf
	("commonsearch: leftX=%d, rightX=%d, OffTransi=%d, StepsY=%d, TransiY=%d\n",
	LeftX, RightX, OffsetTransiFound, StepsBaseY, TransitionsBaseY);
    return TRUE;
}

void DoManyStepsActOrDesact(int ForPage, int FlagStart, int TypeEle1,
    int OffEle1, int TypeEle2, int OffEle2)
{
    int OffsetTransiFound = -1;
    int StepsBaseY = -1;
    int LeftX, RightX;

    if (!CommonSearchForManyStepsOrTransi(TRUE, TypeEle1, OffEle1, TypeEle2,
	    OffEle2, &OffsetTransiFound, &StepsBaseY, NULL, &LeftX, &RightX))
	return;			/* search failed ! */

    // try to find the transition associated to the steps...
    if (OffsetTransiFound == -1 && StepsBaseY != -1) {
	int ScanX;
	// searching in line behind or above...
	int TransiPosiY = StepsBaseY + (FlagStart ? -1 : 1);
	int TransiSearch;
	for (ScanX = LeftX; ScanX <= RightX; ScanX++) {
	    TransiSearch = SearchTransiElement(ForPage, ScanX, TransiPosiY);
	    if (TransiSearch != -1)
		OffsetTransiFound = TransiSearch;
	}
    }
    if (OffsetTransiFound == -1 || StepsBaseY == -1) {
	ShowMessageBox("Error", "Error in selection or not possible...",
	    "Ok");
    } else {
	int ScanX;
	int CptStep = 0;
	int StepSearch;
	int ScanStep;
	printf("DO ACT/DESACT STEPS x1=%d, x2=%d, y=%d\n", LeftX, RightX,
	    StepsBaseY);
	// init all
	for (ScanStep = 0; ScanStep < NBR_SWITCHS_MAX; ScanStep++) {
	    if (FlagStart)
		EditSeqDatas.Transition[OffsetTransiFound].
		    NumStepToActiv[ScanStep] = -1;
	    else
		EditSeqDatas.Transition[OffsetTransiFound].
		    NumStepToDesactiv[ScanStep] = -1;
	}
	// find all the steps to set for the transition
	for (ScanX = LeftX; ScanX <= RightX; ScanX++) {
	    StepSearch = SearchStepElement(ForPage, ScanX, StepsBaseY);
	    if (StepSearch != -1 && CptStep < NBR_SWITCHS_MAX) {
		if (FlagStart)
		    EditSeqDatas.Transition[OffsetTransiFound].
			NumStepToActiv[CptStep] = StepSearch;
		else
		    EditSeqDatas.Transition[OffsetTransiFound].
			NumStepToDesactiv[CptStep] = StepSearch;
		CptStep++;
		printf("StepActDesact++=%d\n", StepSearch);
	    }
	}
    }
}

void DoManyTransitionsLinked(int ForPage, int FlagStart, int TypeEle1,
    int OffEle1, int TypeEle2, int OffEle2)
{
    int LeftX, RightX;
    int TransisBaseY;

    CommonSearchForManyStepsOrTransi(TRUE, TypeEle1, OffEle1, TypeEle2,
	OffEle2, NULL, NULL, &TransisBaseY, &LeftX, &RightX);

    if (TransisBaseY == -1) {
	ShowMessageBox("Error", "Error in selection or not possible...",
	    "Ok");
    } else {
	int NbrTransisLinked = 0;
	int ArrayNumTransiLinked[NBR_SWITCHS_MAX];
	int ScanX;
	int CptTransi = 0;
	int TransiSearch;
	int ScanTransi;
	int ScanTransiArray, ScanTransiArray2;
	// find all the transitions which are linked together
	for (ScanX = LeftX; ScanX <= RightX; ScanX++) {
	    TransiSearch = SearchTransiElement(ForPage, ScanX, TransisBaseY);
	    if (TransiSearch != -1 && CptTransi < NBR_SWITCHS_MAX)
		ArrayNumTransiLinked[NbrTransisLinked++] = TransiSearch;
	}

	if (NbrTransisLinked >= 2) {
	    for (ScanTransiArray = 0; ScanTransiArray < NbrTransisLinked;
		ScanTransiArray++) {
		int TheTransi = ArrayNumTransiLinked[ScanTransiArray];
		int StepToAct = -1;
		int StepToDesact = -1;
		StrTransition *pTheTransi =
		    &EditSeqDatas.Transition[TheTransi];
		// init all
		for (ScanTransi = 0; ScanTransi < NBR_SWITCHS_MAX;
		    ScanTransi++) {
		    if (FlagStart)
			pTheTransi->NumTransLinkedForStart[ScanTransi] = -1;
		    else
			pTheTransi->NumTransLinkedForEnd[ScanTransi] = -1;
		}

		// put the others transitions than itself
		ScanTransi = 0;
		for (ScanTransiArray2 = 0;
		    ScanTransiArray2 < NbrTransisLinked; ScanTransiArray2++) {
		    int NumTransi = ArrayNumTransiLinked[ScanTransiArray2];
		    printf("having num transi linked=%d for transi=%d\n",
			NumTransi, TheTransi);
		    if (NumTransi != TheTransi) {
			printf
			    ("->storing num transi linked=%d for transi=%d\n",
			    NumTransi, TheTransi);
			if (FlagStart) {
			    pTheTransi->NumTransLinkedForStart[ScanTransi++] =
				NumTransi;
			    if (EditSeqDatas.Transition[NumTransi].
				NumStepToDesactiv[0] != -1)
				StepToDesact =
				    EditSeqDatas.Transition[NumTransi].
				    NumStepToDesactiv[0];
			} else {
			    pTheTransi->NumTransLinkedForEnd[ScanTransi++] =
				NumTransi;
			    if (EditSeqDatas.Transition[NumTransi].
				NumStepToActiv[0] != -1)
				StepToAct =
				    EditSeqDatas.Transition[NumTransi].
				    NumStepToActiv[0];
			}
		    }
		}
		// step to activate / descativate
		printf("=>step to activ=%d, step to desactiv=%d\n", StepToAct,
		    StepToDesact);
		if (StepToAct != -1)
		    pTheTransi->NumStepToActiv[0] = StepToAct;
		if (StepToDesact != -1)
		    pTheTransi->NumStepToDesactiv[0] = StepToDesact;
	    }
	} else {
	    ShowMessageBox("Error",
		"Not found at least 2 transitions linked...", "Ok");
	}

    }
}

/* click with the mouse in x and y pixels of the sequential page */
void EditElementInSeqPage(double x, double y)
{
    int PosX, PosY;
    /* correspond to which block ? */
    PosX = x / SEQ_SIZE_DEF;
    PosY = y / SEQ_SIZE_DEF;
    if ((PosX < SEQ_PAGE_WIDTH) && (PosY < SEQ_PAGE_HEIGHT)
	&& (EditDatas.NumElementSelectedInToolBar != -1)) {
	int TypeFound = -1;
	int OffsetFound = -1;
	char TopFound = y > PosY * SEQ_SIZE_DEF
	    && y < PosY * SEQ_SIZE_DEF + SEQ_SIZE_DEF / 2;

	/* save what was selected just before */
	int TypeSeqEleEditedBak = TypeSeqEleEdited;
	int OffsetSeqEleEditedBak = OffsetSeqEleEdited;
	char TopSeqEleEditedBak = TopSeqEleEdited;
	int CurrentSeqPage =
	    SectionArray[InfosGene->CurrentSection].SequentialPage;

	if (EditDatas.NumElementSelectedInToolBar !=
	    NumElementSelectedInToolBarBak)
	    CptNbrClicksDone = 0;
	NumElementSelectedInToolBarBak =
	    EditDatas.NumElementSelectedInToolBar;

//printf("top clicked= %d\n", TopFound );
	TypeSeqEleEdited = -1;
	/* search element selected */
	/* steps are on odd lines, transitions on even ones */
	if (PosY & 1) {
	    OffsetFound = SearchStepElement(CurrentSeqPage, PosX, PosY);
	    if (OffsetFound != -1) {
		TypeFound = ELE_SEQ_STEP;
		TopSeqEleEdited = TypeFound;
	    }
	} else {
	    OffsetFound =
		SearchTransiElement(SectionArray[InfosGene->CurrentSection].
		SequentialPage, PosX, PosY);
	    if (OffsetFound != -1) {
		TypeFound = ELE_SEQ_TRANSITION;
		TopSeqEleEdited = TypeFound;
	    }
	}

	switch (EditDatas.NumElementSelectedInToolBar) {
	case EDIT_POINTER:
	    TypeSeqEleEdited = TypeFound;
	    OffsetSeqEleEdited = OffsetFound;
	    break;
	case ELE_SEQ_STEP:
	case EDIT_SEQ_INIT_STEP:
	case ELE_SEQ_TRANSITION:
	case EDIT_SEQ_STEP_AND_TRANS:
	    if (EditDatas.NumElementSelectedInToolBar == ELE_SEQ_STEP
		|| EditDatas.NumElementSelectedInToolBar == EDIT_SEQ_INIT_STEP
		|| EditDatas.NumElementSelectedInToolBar ==
		EDIT_SEQ_STEP_AND_TRANS) {
		if (PosY & 1) {
		    if (TypeFound != -1) {
			DestroyStep(OffsetFound);
		    } else {
			OffsetFound = CreateStep(CurrentSeqPage, PosX, PosY,
			    (EditDatas.NumElementSelectedInToolBar ==
				EDIT_SEQ_INIT_STEP) ? TRUE : FALSE);
			if (OffsetFound != -1) {
			    TypeSeqEleEdited = ELE_SEQ_STEP;
			    OffsetSeqEleEdited = OffsetFound;
			} else {
			    ShowMessageBox("Error",
				"Sequential memory full for steps", "Ok");
			}
		    }
		} else {
		    ShowMessageBox("Error",
			"A step can't be placed on even lines", "Ok");
		}
	    }
	    if (EditDatas.NumElementSelectedInToolBar == ELE_SEQ_TRANSITION
		|| EditDatas.NumElementSelectedInToolBar ==
		EDIT_SEQ_STEP_AND_TRANS) {
		if (EditDatas.NumElementSelectedInToolBar ==
		    EDIT_SEQ_STEP_AND_TRANS)
		    PosY++;
		if ((PosY & 1) == 0) {
		    if (TypeFound != -1) {
			DestroyTransi(OffsetFound);
		    } else {
			OffsetFound =
			    CreateTransi(CurrentSeqPage, PosX, PosY);
			if (OffsetFound != -1) {
			    TypeSeqEleEdited = ELE_SEQ_TRANSITION;
			    OffsetSeqEleEdited = OffsetFound;
			} else {
			    ShowMessageBox("Error",
				"Sequential memory full for transition",
				"Ok");
			}
		    }
		} else {
		    ShowMessageBox("Error",
			"A transition can't be placed on odd lines", "Ok");
		}
	    }
	    break;
	case EDIT_SEQ_LINK:
	    if (TypeFound != -1)
		CptNbrClicksDone++;
	    if (CptNbrClicksDone == 1) {
		printf
		    ("nbr clicks=1!!! (posi=%s), wait next point to link...\n",
		    (TopFound == 1) ? "top" : "bottom");
		TypeSeqEleEdited = TypeFound;
		OffsetSeqEleEdited = OffsetFound;
		TopSeqEleEdited = TopFound;
		// TODO: modify cursor so that it is a little more
		// explicit...?
	    }
	    if (CptNbrClicksDone == 2) {
		printf("nbr clicks=2!!! (posi=%s), TypeBak=%d, TypeNow=%d\n",
		    (TopFound == 1) ? "top" : "bottom", TypeSeqEleEditedBak,
		    TypeFound);
		if (TypeSeqEleEditedBak == ELE_SEQ_TRANSITION
		    && TypeFound == ELE_SEQ_STEP)
		    DoLinkTransitionAndStep(OffsetSeqEleEditedBak,
			TopSeqEleEditedBak, OffsetFound);
		if (TypeSeqEleEditedBak == ELE_SEQ_STEP
		    && TypeFound == ELE_SEQ_TRANSITION)
		    DoLinkTransitionAndStep(OffsetFound, TopFound,
			OffsetSeqEleEditedBak);
		CptNbrClicksDone = 0;
	    }
	    break;

	case ELE_FREE:
	    if (TypeFound != -1) {
		if (TypeFound == ELE_SEQ_STEP)
		    DestroyStep(OffsetFound);
		if (TypeFound == ELE_SEQ_TRANSITION)
		    DestroyTransi(OffsetFound);
	    }
	    break;

	case EDIT_SEQ_START_MANY_STEPS:
	case EDIT_SEQ_END_MANY_STEPS:
	case EDIT_SEQ_START_MANY_TRANS:
	case EDIT_SEQ_END_MANY_TRANS:
	    if (TypeFound != -1)
		CptNbrClicksDone++;
	    if (CptNbrClicksDone == 1) {
		TypeSeqEleEdited = TypeFound;
		OffsetSeqEleEdited = OffsetFound;
		TopSeqEleEdited = TopFound;
		// TODO: modify cursor so that it is a little more
		// explicit...?
	    }
	    if (CptNbrClicksDone == 2) {
		if (EditDatas.NumElementSelectedInToolBar ==
		    EDIT_SEQ_START_MANY_STEPS
		    || EditDatas.NumElementSelectedInToolBar ==
		    EDIT_SEQ_END_MANY_STEPS) {
		    printf
			("DO_MANY_STEPS:nbr clicks=2!!!, TypeBak=%d, TypeNow=%d\n",
			TypeSeqEleEditedBak, TypeFound);
		    DoManyStepsActOrDesact(CurrentSeqPage,
			EditDatas.NumElementSelectedInToolBar ==
			EDIT_SEQ_START_MANY_STEPS, TypeSeqEleEditedBak,
			OffsetSeqEleEditedBak, TypeFound, OffsetFound);
		} else {
		    printf
			("DO_MANY_TRANSITIONS:nbr clicks=2!!!, TypeBak=%d, TypeNow=%d\n",
			TypeSeqEleEditedBak, TypeFound);
		    DoManyTransitionsLinked(CurrentSeqPage,
			EditDatas.NumElementSelectedInToolBar ==
			EDIT_SEQ_START_MANY_TRANS, TypeSeqEleEditedBak,
			OffsetSeqEleEditedBak, TypeFound, OffsetFound);
		}
		CptNbrClicksDone = 0;
	    }
	    break;

	}
	LoadSeqElementProperties();
    }
}