Anti double code + silence + quitte

SPH · Message par **SPH** » sam. 29/avr./2006 1:59

Salut, bon alors, en vrac, je voudrais savoir :

- quelle est l'instruction pour savoir qu'il y a deja un logiciel EXE fait en PB qui tourne en memoire (afin de ne pas pouvoir en relancer un 2eme)
- quelle est l'instruction pour obliger un programme a tourner en fond afin de ne pas trop prendre le processeur
- quelle est l'instruction pour faire quitter un programme tournant en memoire quand l'utilisateur quitte windows (en effet, je crois que windows indique que le programme tourne et demande si on veux le quitter)
- comment je pourrais faire une interface pour ecrire dedans et quand j'appuyrais sur ENTER, le texte se copie dans la fenetre de tchat de AIM (un logiciel de messagerie) et s'envoie (ca, ca doit etre dur. En fait, ca parait debile mais au passage, les données seraient cryptées; ce qui prend tout son sens la !!)

PS : JE SAIS que certaines questions ont deja ete traité mais RECHERCHE n'a pas ete mon ami

Gillou · Message par **Gillou** » sam. 29/avr./2006 8:20

Pour détecter si le programme est déjà lancé

; #TH32CS_SNAPHEAPLIST = $1
; #TH32CS_SNAPPROCESS = $2
; #TH32CS_SNAPTHREAD = $4
; #TH32CS_SNAPMODULE = $8
; #TH32CS_SNAPALL = #TH32CS_SNAPHEAPLIST | #TH32CS_SNAPPROCESS | #TH32CS_SNAPTHREAD | #TH32CS_SNAPMODULE
; #TH32CS_INHERIT = $80000000
; #PROCESS32LIB = 9999

ProcedureDLL.l CountProcesses(ExeFile.s)
    Protected Count.l, Proc32.PROCESSENTRY32, Temp.s
    Protected Kernel32ID.l, PSapiID.l, SnapshotID.l
    ExeFile = LCase (ExeFile)
    Proc32\dwSize = SizeOf(PROCESSENTRY32)
    Kernel32ID = OpenLibrary ( #PB_Default , "kernel32.dll" )
     If Kernel32ID
        PSapiID = OpenLibrary ( #PB_Default , "psapi.dll" )
        SnapshotID = CallFunction (Kernel32ID, "CreateToolhelp32Snapshot" , #TH32CS_SNAPPROCESS , #Null )
         If SnapshotID
             If CallFunction (Kernel32ID, "Process32First" , SnapshotID, Proc32)
                 Repeat
                     If PSapiID
                        ProcessID = OpenProcess_ ( #PROCESS_QUERY_INFORMATION | #PROCESS_VM_READ , #False , Proc32\th32ProcessID)
                        Temp = Space ( #MAX_PATH )
                         CallFunction (PSapiID, "GetModuleFileNameExA" , ProcessID, #Null , Temp, #MAX_PATH )
                        Temp = Trim (Temp)
                         CloseHandle_ (ProcessID)
                     Else
                        Temp = PeekS ( @Proc32\szExeFile, #MAX_PATH )
                     EndIf
                     If LCase (Temp) = ExeFile
                         If Count = 0
                            MainInstance = Proc32\th32ProcessID
                         EndIf
                        Count + 1
                     EndIf
                 Until CallFunction (Kernel32ID, "Process32Next" , SnapshotID, Proc32) = #False
             EndIf
             CloseHandle_ (SnapshotID)
         EndIf
         CloseLibrary (PSapiID)
         CloseLibrary (Kernel32ID)
     EndIf
     ProcedureReturn Count
EndProcedure

ProcedureDLL.s GetExeFile() ; Retourne l'adresse complète du programme
    ExeName.s = Space (255) : GetModuleFileName_ (0, @ExeName, 255)
     ProcedureReturn ExeName
EndProcedure

If CountProcesses(GetExeFile())>1 : MessageRequester ( "Infos" , "Programme déjà lancé" ) : End : EndIf
MessageRequester ( "Infos" , "Le programme est lancé" )

Pour dire au système de faire tourner le programme quand il travail pas trop
SetPriorityClass_( GetCurrentProcess_(), #IDLE_PRIORITY_CLASS)

SetPriorityClass_ ( GetCurrentProcess_ (), #IDLE_PRIORITY_CLASS )

Détection de la fermeture de session

;Attention, ce code va nécessairement fermer vos applications en cours
;même si vous choisissez d'annuler la fermeture de la session ou de Window

;A noter que vous n'avez que quelques secondes pour agir et annuler l'opération.
;Donc cliquez sur NON dès l'affichage de la Boite de Dialogue!

;Il faut lancer ce code puis lancer une fermeture de Window ou un arrêt de window
;une boite de dialogue vous permettra d'annuler cette opération mais il faudra répondre
;au plus vite à l'affichage de cette boite!

;Nico
;Le 15/11/04
;PureBasic 3.92
;Ce code permet de savoir si Window ferme la session en cours ou
;si l'ordinateur va s'éteindre et de prendre des mesures.

#ENDSESSION_LOGOFF = $80000000

Procedure ProcedureCallback( WindowID , Message, wParam, lParam)
  Resultat = #PB_ProcessPureBasicEvents
   Select Message
     Case #WM_QUERYENDSESSION
       If lParam = 0 ;Window se ferme
        result= MessageRequester ( "Info" , "Window est en cours d'arrêt, l'autoriser?" , #PB_MessageRequester_YesNo )

       ElseIf lParam | #ENDSESSION_LOGOFF ;Fin de session
        result= MessageRequester ( "Info" , "Window va fermer cette Session, l'autoriser?" , #PB_MessageRequester_YesNo )

       EndIf

       If result=6 ;Autorisation de Fermeture
       ;Si vous voulez faire une sauvegarde des données avant la fermeture
       ;la faire maintenant
       ProcedureReturn #True

     ElseIf result=7 ;Annulation de Fermeture
       ProcedureReturn #False
     EndIf

EndSelect
ProcedureReturn Resultat
EndProcedure

   Enumeration
     #Window
   EndEnumeration

   If OpenWindow ( #Window ,0,0,400,400, #PB_Window_SystemMenu|#PB_Window_ScreenCentered , "Pure Basic" )

     SetWindowCallback (@ProcedureCallback())

     Repeat
      EventID.l= WaitWindowEvent ()
       Select EventID
         Case #WM_CLOSE
          Quit=1
       EndSelect
     Until Quit=1
   EndIf

Gillou · Message par **Gillou** » sam. 29/avr./2006 8:25

Et en fin ta dernière question, pour écrire dans une autre fenêtre (c une methode parmi tant d'autre)

Les touches spéciales doivent être écrite comme ça : {ENTER}

ProcedureDLL SendKeys(handle, window$, keys$) ; Ecrit du code pour vous (si handle est précisé, la fonction écrit dans la fenêtre choisie) (si window$ est précisé, la fonction écrit dans la fenêtre portant le nom défini)
     If window$ <> "" : handle = FindWindow_ (0, window$) : EndIf ; Use window$ instead of handle.
     If IsWindow_ (handle) = 0 ; Does the target window actually exist?
         ProcedureReturn 0 ; Nope, so report 0 for failure to type.
     Else
         ; This block gives the target window the focus before typing.
        thread1 = GetWindowThreadProcessId_ ( GetForegroundWindow_ (), 0)
        thread2 = GetWindowThreadProcessId_ (handle, 0)
         If thread1 <> thread2 : AttachThreadInput_ (thread1, thread2, #True ) : EndIf
         SetForegroundWindow_ (handle) ; Target window now has the focus for typing.
         Sleep_ (125) ; 1/8 second pause before typing To prevent fast CPU problems.
         ; Now the actual typing starts.
         keybd_event_ ( #VK_MENU , 0, #KEYEVENTF_KEYUP , 0) ; Release ALT key before typing.
         keybd_event_ ( #VK_CONTROL , 0, #KEYEVENTF_KEYUP , 0) ; Release CONTROL key before typing.
         keybd_event_ ( #VK_SHIFT , 0, #KEYEVENTF_KEYUP , 0) ; Release SHIFT key before typing.
         keybd_event_ ( #VK_LWIN , 0, #KEYEVENTF_KEYUP , 0) ; Release WINDOWS key before typing.
         For r = 1 To Len (keys$)
            vk$ = Mid (keys$, r, 1)
             If vk$ = "{" ; Special key found.
                s = FindString (keys$, "}" , r + 1) - (r + 1) ; Get length of special key.
                s$ = Mid (keys$, r + 1, s) ; Get special key name.
                 Select s$ ; Get virtual key code of special key.
                     Case "ALTDOWN" : keybd_event_ ( #VK_MENU , 0, 0, 0) ; Hold ALT down.
                     Case "ALTUP" : keybd_event_ ( #VK_MENU , 0, #KEYEVENTF_KEYUP , 0) ; Release ALT.
                     Case "BACKSPACE" : vk = #VK_BACK
                     Case "CONTROLDOWN" : keybd_event_ ( #VK_CONTROL , 0, 0, 0) ; Hold CONTROL down.
                     Case "CONTROLUP" : keybd_event_ ( #VK_CONTROL , 0, #KEYEVENTF_KEYUP , 0) ; Release CONTROL.
                     Case "DELAY" : vk = 0 : Sleep_ (1000) ; Delay typing for one second.
                     Case "DELETE" : vk = #VK_DELETE
                     Case "DOWN" : vk = #VK_DOWN
                     Case "END" : vk = #VK_END
                     Case "ENTER" : vk = #VK_RETURN
                     Case "ESCAPE" : vk = #VK_ESCAPE
                     Case "F1" : vk = #VK_F1
                     Case "F2" : vk = #VK_F2
                     Case "F3" : vk = #VK_F3
                     Case "F4" : vk = #VK_F4
                     Case "F5" : vk = #VK_F5
                     Case "F6" : vk = #VK_F6
                     Case "F7" : vk = #VK_F7
                     Case "F8" : vk = #VK_F8
                     Case "F9" : vk = #VK_F9
                     Case "F10" : vk = #VK_F10
                     Case "F11" : vk = #VK_F11
                     Case "F12" : vk = #VK_F12
                     Case "HOME" : vk = #VK_HOME
                     Case "INSERT" : vk = #VK_INSERT
                     Case "LEFT" : vk = #VK_LEFT
                     Case "PAGEDOWN" : vk = #VK_NEXT
                     Case "PAGEUP" : vk = #VK_PRIOR
                     Case "PRINTSCREEN" : vk = #VK_SNAPSHOT
                     Case "RETURN" : vk = #VK_RETURN
                     Case "RIGHT" : vk = #VK_RIGHT
                     Case "SPACE" : vk = #VK_SPACE
                     Case "SHIFTDOWN" : shifted = 1 : keybd_event_ ( #VK_SHIFT , 0, 0, 0) ; Hold SHIFT down.
                     Case "SHIFTUP" : shifted = 0 : keybd_event_ ( #VK_SHIFT , 0, #KEYEVENTF_KEYUP , 0) ; Release SHIFT.
                     Case "TAB" : vk = #VK_TAB
                     Case "UP" : vk = #VK_UP
                     Case "WINDOWS" : vk = #VK_LWIN
                 EndSelect
                 If Left (s$, 3) <> "ALT" And Left (s$, 7) <> "CONTROL" And Left (s$, 5) <> "SHIFT"
                     keybd_event_ (vk, 0, 0, 0) : keybd_event_ (vk, 0, #KEYEVENTF_KEYUP , 0) ; Press the special key.
                 EndIf
                r + s + 1 ; Continue getting the keystrokes that follow the special key.
             Else
                vk = VkKeyScanEx_ ( Asc (vk$), GetKeyboardLayout_ (0)) ; Normal key found.
                 If vk > 303 And shifted = 0 : keybd_event_ ( #VK_SHIFT , 0, 0, 0) : EndIf ; Due to shifted character.
                 keybd_event_ (vk, 0, 0, 0) : keybd_event_ (vk, 0, #KEYEVENTF_KEYUP , 0) ; Press the normal key.
                 If vk > 303 And shifted = 0 : keybd_event_ ( #VK_SHIFT , 0, #KEYEVENTF_KEYUP , 0) : EndIf ; Due to shifted character.
             EndIf
         Next
         If thread1 <> thread2 : AttachThreadInput_ (thread1, thread2, #False ) : EndIf ; Finished typing to target window!
         keybd_event_ ( #VK_MENU , 0, #KEYEVENTF_KEYUP , 0) ; Release ALT key in case user forgot.
         keybd_event_ ( #VK_CONTROL , 0, #KEYEVENTF_KEYUP , 0) ; Release CONTROL key in case user forgot.
         keybd_event_ ( #VK_SHIFT , 0, #KEYEVENTF_KEYUP , 0) ; Release SHIFT key in case user forgot.
         keybd_event_ ( #VK_LWIN , 0, #KEYEVENTF_KEYUP , 0) ; Release WINDOWS key in case user forgot.
         ProcedureReturn 1 ; Report successful typing! : )
     EndIf
EndProcedure

SPH · Message par **SPH** » sam. 29/avr./2006 8:39

Et bien, quelle surprise !! Gillou, tu pouvais quand meme dormir cette nuit au lieu de coder pour me repondre

Pour AIM, je precise (sans avoir verifié si ton code le fait ou pas) que ce que je veux, c'est precisement de transferer et envoyer le message dans la fenetre AIM quand on appuie sur entrée (ou autre touche)

Merci pour tout, je vais regarder tout ca et je te dirais quoi

Gillou · Message par **Gillou** » sam. 29/avr./2006 8:51

Tu colles la procedure sendkeys avec le code ci-dessous

RunProgram ( "notepad.exe" )

win = OpenWindow ( #PB_Any , 0, 0, 200, 200, "test" , #PBWIN0 )
If win And CreateGadgetList ( WindowID (win))
EditorGadget (0,0,0,200,180)
ButtonGadget (1,0,180,200,20, "Envoyer" )
Repeat
     Select WaitWindowEvent ()
         Case #PB_Event_Gadget
             Select EventGadget()
                 Case 1
                    SendKeys(0, "Sans titre - Bloc-notes" , GetGadgetText (0))
             EndSelect
         Case #PB_Event_CloseWindow
            Quit = 1
     EndSelect
Until Quit = 1
EndIf

SPH · Message par **SPH** » sam. 29/avr./2006 10:38

Alors, j'ai testé et :

- Ton premier code a une erreur STRUCTURE NOT FOUND PROCESSENTRY32
- Ton 2eme code (une phrase de code) ne fait pas d'erreur et s'il est utilisable tel quel, je t'en remercie
- Ton 3eme code : pas encore testé
- Ton 4eme code fait une erreur CONSTANT NOT FOUND #PBWIN0

ps : j'ai PB3.94 et aucune lib extra installé

Gillou · Message par **Gillou** » sam. 29/avr./2006 12:03

Structure PROCESSENTRY32
dwSize.l
cntUsage.l
th32ProcessID.l
*th32DefaultHeapID.l
th32ModuleID.l
cntThreads.l
th32ParentProcessID.l
pcPriClassBase.l
dwFlags.l
szExeFile.b [260]
EndStructure

#PBWIN0 = 1|13107200|13238272

Je l'ai corrigé pour la v4 (je vais essayer de retrouver les sources de la 3.94)

Flype · Message par **Flype** » sam. 29/avr./2006 12:20

@SPH

tous les exemples qu'on te montre ici et qui ne fonctionnent pas chez toi c'est parceque c'est des exemples pour PB4.0.

et si tu trouves un bug avec PB3.94, il faut savoir qu'il n'y aura plus de corrections de bugs pour cette version.

par contre çà me fait penser, étant donné ce constat, qu'il serait intéressant d'avoir une liste propre, la plus exhaustive possible, recensant les bugs connus de PB3.94 afin de mieux les contourner. non ?

SPH · Message par **SPH** » sam. 29/avr./2006 12:41

Ha ok, j'ai enfin trouver où etais la V4 (dans mon compte perso) !!!!

Dr. Dri · Message par **Dr. Dri** » sam. 29/avr./2006 12:44

@gillou
Je me disais que j'avais déjà vu ce code quelque part
(le premier)

Dri